home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #4 / Amiga Plus CD - 2000 - No. 4.iso / PowerPC / Games / Battalion / source / graphics.c < prev    next >
C/C++ Source or Header  |  1999-12-23  |  136KB  |  4,325 lines
  1. /****************************************************************/
  2. /* code copyright 1995-1996 Andrew Johnson - ALL RIGHTS RESERVED*/
  3. /*                          ajohnson@eecs.uic.edu               */
  4. /*                                                              */
  5. /*                      Electronic Visualization Lab (M/C 154)  */
  6. /*                      University of Illinois at Chicago       */
  7. /*                      851 South Morgan St. Room 1120 SEO      */
  8. /*                      Chicago, IL 60607-7053                  */
  9. /*                                                              */
  10. /*                      (312) 996-3002     (312) 413-7585 FAX   */
  11. /***********************************************************************/
  12. /* graphics.c v 1.3                                                    */
  13. /* high level graphics routines for battalion                          */
  14. /***********************************************************************/
  15.  
  16. #include "battalion.h"
  17.  
  18.     /*************/
  19.     /* colours   */
  20.     /*************/
  21.  
  22.     float colorolive[4]         = {0,    0.34,  0.0,  0.0};
  23.     float planeGreen[4]         = {0.21, 0.49,  0.0,  0.0};
  24.     float planeGreen2[4]        = {0.25, 0.60,  0.0,  0.0}; 
  25.     float planeGreen3[4]        = {0.10, 0.25,  0.0,  0.0}; 
  26.     float colorgreen[4]         = {0.0,  0.9,  0.1,  0.0};
  27.  
  28.     float colorblack[4]         = {0.2,  0.2,  0.2,  0.95};
  29.  
  30.     float colorred[4]           = {0.98, 0.17, 0.0,  0.7};
  31.     float colorred_50[4]        = {0.49, 0.085, 0.0,  0.7}; /* colorred * 0.5 */
  32.     float colorred2[4]          = {1.0,  0.0,  0.0,  0.0};
  33.     float colorred3[4]          = {0.5,  0.08, 0.0,  0.7};
  34.  
  35.     float colormaserblue[4]     = {0.3,  0.7,  1.0,  0.75};
  36.     float colormaserblue2[4]    = {0.0,  1.0,  1.0,  0.75};
  37.  
  38.     float colorwhite[4]         = {1.0,  1.0,  1.0,  0.2};
  39.     float colorwhite2[4]        = {1.0,  1.0,  1.0,  0.4}; /* dying vapour */
  40.  
  41.     float colorsnow[4]          = {0.8,  0.8,  0.9,  0.4};
  42.     float colorsnow2[4]         = {0.7,  0.7,  0.8,  0.4};
  43.  
  44.     float colorgrey1[4]         = {0.5,  0.5,  0.5,  0.8};
  45.     float colorgrey1_50[4]      = {0.25, 0.25, 0.25, 0.4}; /* colorgrey * 0.5 */
  46.     float colorgrey2[4]         = {0.7,  0.7,  0.7,  0.0};
  47.     float colorgrey3[4]         = {0.6,  0.6,  0.6,  0.0};
  48.     float colorgrey3_50[4]      = {0.3,  0.3,  0.3,  0.0}; /* colorgrey3 * 0.5 */
  49.     float colorgrey4[4]         = {0.55, 0.55, 0.55, 0.0};
  50.  
  51.     float colorbrown[4]         = {0.75, 0.33, 0.0,  0.8};
  52.     float colorbeige[4]         = {0.75, 0.75, 0.5,  0.7};
  53.  
  54.     float colorblue[4]          = {0.0,  0.0,  1.0,  0.6};
  55.     float colorblue2[4]         = {0.0,  0.0,  0.7,  0.0};
  56.     float colorwater[4]         = {0.0,  0.25, 0.5,  0.0};
  57.  
  58.     float colorsnowvapour[4]    = {0.3,  0.3,  1.0,  0.4};
  59.  
  60.     float coloryellow[4]        = {1.0,  1.0,  0.0,  0.0};
  61.     float colormaseryellow[4]   = {1.0,  0.7,  0.0,  0.0};
  62.     float colororange[4]        = {1.0,  0.7,  0.0,  0.0};
  63.  
  64.     float healthGreen[4]        = {0.21, 0.49, 0.0,  0.0}; 
  65.  
  66.     float treeColor[4]          = {0.03, 0.34, 0.025, 0};
  67.     float treeColor2[4]         = {0.05, 0.4,  0.025, 0};
  68.     
  69.     /*************/
  70.     /* objects   */
  71.     /*************/
  72.  
  73.     GLuint 
  74.         plaintank, slagtank, masertank, slagmasertank,  
  75.         launchertank, slaglaunchertank, helo, slagHelo, 
  76.         bigRotor, smallRotor, propeller,  
  77.  
  78.         airplaneBody, fighterBody,  
  79.     
  80.         monsterleg, monsterHead,
  81.         monsterTail, monsterBody,
  82.         monsterSimpleHead, monsterSimpleTail, 
  83.         flutterHead,  
  84.  
  85.         techsBody, techsHead, techsShadow, 
  86.         techsSimpleBody, techsSimpleHead, 
  87.         
  88.         watershellObj, heroshellObj,  
  89.  
  90.         tankShadow, planeShadow, fighterShadow, 
  91.  
  92.         flutterShadow, flutterBody, flutterXMas, 
  93.         flutterWing1, flutterWing2, 
  94.  
  95.         planeDotsObj, planeDotsObjD0,
  96.     
  97.         shellObj, shell2Obj, 
  98.  
  99.         titleObj, titleObjOO, titleObjOOO, 
  100.         lowDPlane, highDPlane, bigPlane, 
  101.                 
  102.         roundTreeShadow,   
  103.  
  104.         boom1Obj, boom2Obj, boom3Obj, boom4Obj, boom5Obj, 
  105.         boom6Obj, boom7Obj, boom8Obj, boom9Obj, boom10Obj, 
  106.  
  107.         boom1ObjD0, boom2ObjD0, boom3ObjD0, boom4ObjD0, boom5ObjD0, 
  108.         boom6ObjD0, boom7ObjD0, boom8ObjD0, boom9ObjD0, boom10ObjD0, 
  109.         
  110.         strip1Obj, strip2Obj, strip3Obj, 
  111.         strip1ObjD0, strip2ObjD0, strip3ObjD0, 
  112.     
  113.         powerTower,
  114.         genericWindows, 
  115.  
  116.         building1Obj, building2Obj, building7Obj, building9Obj,  building9ObjOO,  
  117.         building10Obj, building12Obj, building14Obj, building19Obj,  
  118.         building20Obj, building21Obj, building31Obj, building32Obj,  
  119.         building5Obj,
  120.         building1ObjD0, building2ObjD0, building5ObjD0, building12ObjD0,
  121.         building19ObjD0, building20ObjD0, building21ObjD0;
  122.  
  123.     /***************************/
  124.     /* texture mapping stuff   */
  125.     /***************************/
  126.  
  127.     GLuint leftScreen, rightScreen;
  128.     GLuint treeWood, roadtex, officeLogo;
  129.  
  130.     char picleft[32400], picright[32400]; /* 180 x 180 tmap arrays*/
  131.                                           /* only 128 x 128 in use now */
  132.     char officeLogoData[32400];
  133.                   
  134.     char treeWoodData[5000];
  135.     char roadtexData[5000];
  136.     
  137.  
  138.     struct road roadsOnPlane[MAXROADSONPLANE];
  139.  
  140. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  141.  
  142. void doTexStuff(char * dataPath, char * fileName, int width, int height,
  143.                 char * TheArray, GLuint * theObj, int interpolation, int repeat)
  144.     {
  145.     register int x, y;
  146.     char fullPath[MAXPATH];
  147.     int arrayLoc;
  148.     FILE * imageFile;
  149.  
  150.     strcpy(fullPath, dataPath);
  151.     strcat(fullPath, fileName);
  152.     imageFile = fopen(fullPath, "r");
  153.         
  154.     if (imageFile == NULL) 
  155.         showError("Cannot find texture file in data directory");
  156.     else
  157.         {           
  158.         for (y = 0; y < height; y++)
  159.             for (x = 0; x < width; x++)
  160.                     {
  161.                     arrayLoc = (height-1-y) * width + (width-1-x);
  162.                     TheArray[arrayLoc]  = (char) fgetc(imageFile);
  163.                     }
  164.                     
  165.         *theObj = glGenLists(1);                    
  166.         glNewList(*theObj, GL_COMPILE);
  167.         
  168.             glTexImage2D(GL_TEXTURE_2D, 0, 1, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, (const GLvoid *) TheArray);
  169.  
  170.             if (repeat)
  171.                 {
  172.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  173.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  174.                 }
  175.             else
  176.                 {                   
  177.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  178.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  179.                 }
  180.             
  181.             if (interpolation)
  182.                 {
  183.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  184.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  185.                 }
  186.             else
  187.                 {
  188.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  189.                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  190.                 }
  191.             
  192.             glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  193.  
  194.         glEndList();
  195.         
  196.         fclose(imageFile);
  197.         }
  198.     }
  199.  
  200. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  201. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  202. /* create the objects to be used in the game                     */
  203. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  204.  
  205. void makeObjects(char * dataPath)
  206.     {
  207.     GLfloat lineWidthNow;
  208. GLenum code;
  209.  
  210.     /********************/
  211.     /* load in textures */
  212.     /********************/
  213.  
  214. do {
  215. code = glGetError();
  216. } while (code != GL_NO_ERROR);
  217.  
  218. #ifdef MACVERSION
  219.  
  220. /* this line generates a GLenum error under the mac mesa 68k version, but not
  221. oddly enough in the mac PPC version - it may be because it is the first OpenGL call*/
  222.  
  223.     doTexStuff(dataPath, "TEXTURES:screenleft.tex", 128, 128, picleft, &leftScreen, 0, 0);
  224.  
  225.     doTexStuff(dataPath, "TEXTURES:screenright.tex", 128, 128, picright, &rightScreen, 0, 0);
  226.  
  227.     doTexStuff(dataPath, "TEXTURES:treewood.tex", 64, 64, treeWoodData, &treeWood, 1, 0);
  228.     doTexStuff(dataPath, "TEXTURES:road.tex", 64, 64, roadtexData, &roadtex, 1, 0);
  229.  
  230. #else
  231.     doTexStuff(dataPath, "TEXTURES/screenleft.tex", 128, 128, picleft, &leftScreen, 0, 0);
  232.     doTexStuff(dataPath, "TEXTURES/screenright.tex", 128, 128, picright, &rightScreen, 0, 0);
  233.  
  234.     doTexStuff(dataPath, "TEXTURES/treewood.tex", 64, 64, treeWoodData, &treeWood, 1, 0);
  235.     doTexStuff(dataPath, "TEXTURES/road.tex", 64, 64, roadtexData, &roadtex, 1, 0);
  236. #endif
  237.  
  238. /*     doTexStuff(dataPath,"TEXTURES/logo.tex", 128, 128, officeLogoData, &officeLogo, 0, 0);
  239. */
  240.  
  241.     /********************/
  242.     /* make the objects */
  243.     /********************/
  244.  
  245.     plaintank           = makeTank();
  246.     slagtank            = makeSlagTank();
  247.     masertank           = makeMaserTank();
  248.     slagmasertank       = makeSlagMaserTank();
  249.     launchertank        = makeLauncherTank();
  250.     slaglaunchertank    = makeSlagLauncherTank();
  251.     helo                = makeHelo();
  252.     slagHelo            = makeSlagHelo();
  253.     bigRotor            = makeBigRotor();
  254.     smallRotor          = makeSmallRotor();
  255.     propeller           = makePropeller();
  256.     
  257.     monsterleg          = makeLeg();
  258.     monsterHead         = makeHead();
  259.     monsterSimpleHead   = makeSimpleHead();
  260.     monsterSimpleTail   = makeSimpleTail();
  261.     monsterTail         = makeTail();
  262.     monsterBody         = makeBody();
  263.     flutterHead         = makeFlutterHead();
  264.     techsBody           = makeTechsBody();
  265.     techsHead           = makeTechsHead();
  266.     techsSimpleBody     = makeTechsSimpleBody();
  267.     techsSimpleHead     = makeTechsSimpleHead();
  268.     techsShadow         = makeTechsShadow();
  269.  
  270.     tankShadow          = makeTankShadow();
  271.     planeShadow         = makePlaneShadow();
  272.     fighterShadow       = makeFighterShadow();
  273.  
  274.     shellObj            = glGenLists(1);     
  275.     shell2Obj           = makeshell2();
  276.     heroshellObj        = makeHeroShell();
  277.     watershellObj       = makeWaterShell();
  278.  
  279.     titleObj            = makeTitles(1);
  280.     titleObjOO          = makeTitles(0);
  281.     titleObjOOO         = makeTitles(-1);
  282.     
  283.     planeDotsObj        = makePlaneDots(1);
  284.     planeDotsObjD0      = makePlaneDots(0);
  285.  
  286.     powerTower          = makePowerTower(); 
  287.     genericWindows      = makeGenericWindows(); 
  288.  
  289.     strip1Obj           = makeStrip1(1);
  290.     strip2Obj           = makeStrip2(1);
  291.     strip3Obj           = makeStrip3(1);
  292.     strip1ObjD0         = makeStrip1(0);
  293.     strip2ObjD0         = makeStrip2(0);
  294.     strip3ObjD0         = makeStrip3(0);
  295.  
  296.     building1Obj        = makebuilding1(1); 
  297.     building1ObjD0      = makebuilding1(0); 
  298.     building2Obj        = makebuilding2(1);
  299.     building2ObjD0      = makebuilding2(0);
  300.     building5Obj        = makebuilding5(1);
  301.     building5ObjD0      = makebuilding5(0);
  302.     building7Obj        = makebuilding7();
  303.     building9Obj        = makebuilding9(0);
  304.     building9ObjOO      = makebuilding9(1);
  305.     
  306.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  307.     building10Obj       = makebuilding10();
  308.     glLineWidth(lineWidthNow);
  309.     
  310.     building12Obj       = makebuilding12(1);
  311.     building12ObjD0     = makebuilding12(0);
  312.     building14Obj       = makebuilding14();
  313.     building19Obj       = makebuilding19(1);
  314.     building19ObjD0     = makebuilding19(0);
  315.     building20Obj       = makebuilding20(1);
  316.     building20ObjD0     = makebuilding20(0);
  317.     building21Obj       = makebuilding21(1);
  318.     building21ObjD0     = makebuilding21(0);
  319.     building31Obj       = makebuilding31();
  320.     building32Obj       = makebuilding32();
  321.  
  322.     lowDPlane           = makeLowDPlane();
  323.     highDPlane          = makeHighDPlane();
  324.     bigPlane            = makeBigPlane();
  325.  
  326.     airplaneBody        = makeAirplaneBody();
  327.     fighterBody         = makeFighterBody();
  328.     flutterShadow       = makeFlutterShadow();
  329.     flutterXMas         = makeFlutterXMas();
  330.     flutterBody         = makeFlutterBody();
  331.     flutterWing1        = makeFlutterWing1();
  332.     flutterWing2        = makeFlutterWing2();
  333.  
  334.     roundTreeShadow     = makeRoundTreeShadow();
  335.  
  336.     makeBooms();
  337.     
  338.     initFonts();
  339.     }
  340.  
  341. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  342. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  343. /* draw a rectangular shadow on the ground                       */
  344. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  345.  
  346. void drawShadow (float x, float z, float wx, float wz)
  347.     {
  348.     float v[3];
  349.     v[1] = SHADOWS;
  350.  
  351.     glBegin(GL_QUADS);
  352.         v[0] = x+wx; v[2] = z+wz;
  353.         glVertex3fv(v);
  354.  
  355.         v[2] = z-wz;
  356.         glVertex3fv(v);
  357.  
  358.         v[0] = x-wx;
  359.         glVertex3fv(v);
  360.  
  361.         v[2] = z+wz;
  362.         glVertex3fv(v);
  363.     glEnd();
  364.     }
  365.  
  366. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  367. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  368. /* draw a  hunter                                                */
  369. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  370.  
  371. void makeCHH(int dam)
  372.     {
  373.     if (dam > 16)
  374.         makercube(-0.15, -0.05, -0.2, 0.07, 0.07, 0.1, colorblue);
  375.     else
  376.         makeitd(0, colorblue,  -0.15, -0.05, -0.2, 0.07, 0.07, 0.1);
  377.  
  378.     if (dam > 12)
  379.         makercube(0.15, -0.05, -0.2, 0.07, 0.07, .1, colorblue);
  380.     else
  381.         makeitd(1, colorblue, 0.15, -0.05, -0.2, 0.07, 0.07, .1);
  382.  
  383.     if (dam > 8)
  384.         makercube(0.0, -0.05, 0.1, 0.2, 0.05, 0.1, colorgrey1);
  385.     else
  386.         makeitd(0, colorgrey1,  0.0, -0.05, 0.1, 0.2, 0.05, 0.1);
  387.  
  388.     if (dam > 4)
  389.         makercube(0.0, -0.05, -0.2, 0.1, 0.05, 0.2, colorgrey1);
  390.     else
  391.         makeitd(1, colorgrey1,  0.0, -0.05, -0.2, 0.1, 0.05, 0.2);
  392.  
  393.     if (dam > 0)
  394.         makeitPyr(3, colorgrey2,  0.0, +0.05, 0.1, 0.2, 0.05, 0.1);
  395.     else
  396.         makeitPyr(3, colorgrey1,  0.0, +0.05, 0.1, 0.2, 0.05, 0.1);
  397.  
  398.     makercube( 0.05, -0.1,  0.15, 0.02, 0.01, 0.02, colorwhite);
  399.     makercube(-0.05, -0.1,  0.15, 0.02, 0.01, 0.02, colorwhite);
  400.     makercube( 0.05, -0.1, -0.35, 0.02, 0.01, 0.02, colorwhite);
  401.     makercube(-0.05, -0.1, -0.35, 0.02, 0.01, 0.02, colorwhite);
  402.     }
  403.  
  404.  
  405. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  406. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  407. /* draw a helicopter                                             */
  408. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  409.  
  410. void drawHelo(float percent,  int slag)
  411.     {
  412.     GLint shadeNow;
  413.     
  414.     glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
  415.     
  416.     /*************/
  417.     /* draw body */
  418.     /*************/
  419.  
  420.     glShadeModel(GL_FLAT);
  421.  
  422.     if (!slag)
  423.         glCallList(helo);
  424.     else
  425.         glCallList(slagHelo);
  426.         
  427.     glShadeModel(shadeNow);
  428.  
  429.     /***************/
  430.     /* draw rotors */
  431.     /***************/
  432.  
  433.     glPushMatrix();
  434.         glRotatef(-percent, 0, 1, 0);
  435.         glCallList(bigRotor);   
  436.     glPopMatrix();
  437.  
  438.     /********************/
  439.     /* draw tail rotor  */
  440.     /********************/
  441.  
  442.     glPushMatrix();
  443.         glTranslatef(0.04,  0,  0.375);
  444.         glRotatef( -percent, 1, 0, 0);
  445.         glCallList(smallRotor);
  446.     glPopMatrix();
  447.         }
  448.  
  449.     
  450. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  451. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  452. /* draw a bomber                                                 */
  453. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  454.  
  455. void drawAirplane(int counter)
  456.     {
  457.     float percent;
  458.  
  459.     percent = counter * 10.0;
  460.  
  461.     glCallList(airplaneBody);
  462.     
  463.     /*******************/
  464.     /* draw propellers */
  465.     /*******************/
  466.  
  467.     glPushMatrix();
  468.         glTranslatef(-0.09,  -0.014,  -0.07);
  469.         glRotatef( -percent, 0, 0, 1);
  470.         glCallList(propeller);  
  471.     glPopMatrix();
  472.  
  473.     glPushMatrix();
  474.         glTranslatef(+0.09,  -0.014,  -0.07);
  475.         glRotatef( -percent, 0, 0, 1);
  476.         glCallList(propeller);  
  477.     glPopMatrix();
  478.  
  479.     }
  480.  
  481. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  482. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  483. /* draw a fighter                                                 */
  484. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  485.  
  486. void drawFighter(void)
  487.     {
  488.     glCallList(fighterBody);    
  489.     }
  490.         
  491.  
  492.  
  493. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  494. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  495. /* draw Googelon                                                 */
  496. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  497.  
  498. void drawMonster(struct monsterInfo monster, int counter,
  499.                 int itsChristmas, int detail)
  500.     {    
  501.     float v[4];
  502.  
  503.     /*********************/
  504.     /* googelon's shadow */
  505.     /*********************/
  506.  
  507. static    float googShadow1[3] = {0.1, SHADOWS, -0.5};
  508. static    float googShadow2[3] = {0.0, SHADOWS, -0.7};
  509. static    float googShadow3[3] = {-0.1, SHADOWS, -0.5};
  510.  
  511.     glPushMatrix();
  512.  
  513.         glRotatef(.1*monster.headHorzRotate, 0, 1, 0);
  514.  
  515.         /********/
  516.         /* head */
  517.         /********/
  518.  
  519.         glPushMatrix();
  520.             glRotatef(.1*monster.headVertRotate, 1, 0, 0);
  521.  
  522.             glCallList(monsterHead);
  523.                     
  524.             if (itsChristmas)
  525.                 {
  526.                 glPushMatrix();
  527.                     glScalef(1.2,  .5,  1.2);
  528.                     glTranslatef(0.0,  PLANEY+1.7,  0.0);
  529.                         glColor3fv(colorwhite);
  530.                         v[0] = v[1] = v[2] = 0;
  531.                         v[3] = .14;
  532.                         andysphdraw(v, 4);
  533.                 glPopMatrix();
  534.                 glPushMatrix();
  535.                     glTranslatef(-0.15,  PLANEY+1.55,  -0.15);
  536.                     glScalef(0.15,  0.2,  0.15);
  537.                     drawClosedCone(colorred, colorred, 1);
  538.                 glPopMatrix();
  539.  
  540.                 glPushMatrix();
  541.                     glTranslatef(-0.09,  PLANEY+1.75,  0.04);
  542.                     glRotatef(.1*(1100), 1, 0, 0);
  543.                     glRotatef(.1*(450), 0, 0, 1);
  544.                     glScalef(.04,  .11,  .1);
  545.                     drawClosedCone(colorred, colorred, 1);
  546.                 glPopMatrix();
  547.  
  548.                 glColor3fv(colorwhite);
  549.                 v[0] = -0.15;
  550.                 v[1] = PLANEY+1.6;
  551.                 v[2] = 0.1;
  552.                 v[3] = 0.05;
  553.                 andysphdraw(v, 4);
  554.                 }
  555.             
  556.         glPopMatrix();   
  557.  
  558.         /********/
  559.         /* body */
  560.         /********/
  561.  
  562.         glCallList(monsterBody);
  563.     
  564.         /***********************/
  565.         /* legs, feet and toes */
  566.         /***********************/
  567.  
  568.         glPushMatrix();
  569.             glTranslatef(0.2,  monster.rot1,  monster.rot2);
  570.             glCallList(monsterleg);
  571.             glTranslatef(-0.4,   -2*monster.rot1,  -2*monster.rot2);
  572.             glCallList(monsterleg);
  573.         glPopMatrix();
  574.  
  575.         if ((!monster.monsterIsDead) && (detail > 0))
  576.               {
  577.               glColor4fv(colorblack);
  578.               
  579.               drawShadow (0.0,   0.0,          0.2, 0.2);
  580.               drawShadow (0.2,   monster.rot2, 0.1, 0.15);
  581.               drawShadow (-0.2, -monster.rot2, 0.1, 0.15);
  582.               }
  583.  
  584.         /********/
  585.         /* tail */
  586.         /********/
  587.     
  588.             glRotatef(sin(counter * 0.15915)*10, 0, 1, 0); /* 1/(2 * pi) */
  589.  
  590.             glCallList(monsterTail);
  591.  
  592.             if (itsChristmas)
  593.                 {
  594.                 glPushMatrix();
  595.                     glTranslatef(-0.15,  PLANEY+0.85,  -0.45);
  596.                     glScalef(0.15,  0.15,  0.15);
  597.                     drawClosedCone(colorbeige, colorbrown, 1);
  598.                 glPopMatrix();
  599.    
  600.                 glPushMatrix();
  601.                     glTranslatef(0.0,  PLANEY+0.5,  -0.3);
  602.                     glScalef(1,  1.5,  1);
  603.                     glColor3fv(colorbeige);
  604.                     v[0] = v[1] = v[2] = 0;
  605.                     v[3] = 0.2;
  606.                     andysphdraw(v, 4);
  607.                 glPopMatrix();
  608.                 }
  609.  
  610.             if ((!monster.monsterIsDead) && (detail > 0))
  611.                 {
  612.                 glColor4fv(colorblack);
  613.                 
  614.                 drawShadow (0.0,  -0.25,  0.1,  0.25);
  615.  
  616.                 glColor3fv(colorblack);
  617.  
  618.                 glBegin(GL_TRIANGLES);
  619.                     glVertex3fv(googShadow1);
  620.                     glVertex3fv(googShadow2);
  621.                     glVertex3fv(googShadow3);
  622.                 glEnd();
  623.                 }
  624.  
  625.     glPopMatrix();
  626.     }
  627.  
  628. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  629. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  630. /* draw SIMPLIFIED Googelon (to save time in monsterview)        */
  631. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  632.  
  633. void drawSimpleMonster(struct monsterInfo monster, int counter,
  634.                 int itsChristmas, int detail)
  635.     {    
  636.     float v[4];
  637.  
  638.     /*********************/
  639.     /* googelon's shadow */
  640.     /*********************/
  641.  
  642.     glPushMatrix();
  643.  
  644.         glRotatef(.1*monster.headHorzRotate, 0, 1, 0);
  645.  
  646.         /********/
  647.         /* head */
  648.         /********/
  649.  
  650.         glPushMatrix();
  651.             glRotatef(.1*monster.headVertRotate, 1, 0, 0);
  652.  
  653.             glCallList(monsterSimpleHead);
  654.                     
  655.             if (itsChristmas)
  656.                 {
  657.                 glPushMatrix();
  658.                     glScalef(1.2,  .5,  1.2);
  659.                     glTranslatef(0.0,  PLANEY+1.7,  0.0);
  660.                         glColor3fv(colorwhite);
  661.                         v[0] = v[1] = v[2] = 0;
  662.                         v[3] = .14;
  663.                         andysphdraw(v, 4);
  664.                 glPopMatrix();
  665.                 glPushMatrix();
  666.                     glTranslatef(-0.15,  PLANEY+1.55,  -0.15);
  667.                     glScalef(0.15,  0.2,  0.15);
  668.                     drawClosedCone(colorred, colorred, 1);
  669.                 glPopMatrix();
  670.  
  671.                 glPushMatrix();
  672.                     glTranslatef(-0.09,  PLANEY+1.75,  0.04);
  673.                     glRotatef(.1*(1100), 1, 0, 0);
  674.                     glRotatef(.1*(450), 0, 0, 1);
  675.                     glScalef(.04,  .11,  .1);
  676.                     drawClosedCone(colorred, colorred, 1);
  677.                 glPopMatrix();
  678.  
  679.                 glColor3fv(colorwhite);
  680.                 v[0] = -0.15;
  681.                 v[1] = PLANEY+1.6;
  682.                 v[2] = 0.1;
  683.                 v[3] = 0.05;
  684.                 andysphdraw(v, 4);
  685.                 }
  686.             
  687.         glPopMatrix();   
  688.  
  689.         /********/
  690.         /* body */
  691.         /********/
  692.  
  693.         makercubeTopBack(0.0, PLANEY+0.5, 0.0,  0.2,  0.3, 0.2,  colorred);
  694.         makercubeTopBack(0.0, PLANEY+0.9, 0.0,  0.15, 0.2, 0.15, colorred);
  695.     
  696.         /***********************/
  697.         /* legs, feet and toes */
  698.         /***********************/
  699.  
  700.         glPushMatrix();
  701.             glTranslatef(0.2,  monster.rot1,  monster.rot2);
  702.  
  703.             makercubeTopBack( 0.0,   PLANEY+0.2,  0.0,   0.1,  0.2,  0.1,  colorred);
  704.             makercubeTopBack( 0.0,   PLANEY+0.06, 0.17,  0.1,  0.06, 0.08, colorred);
  705.  
  706.             glTranslatef(-0.4,   -2*monster.rot1,  -2*monster.rot2);
  707.  
  708.             makercubeTopBack( 0.0,   PLANEY+0.2,  0.0,   0.1,  0.2,  0.1,  colorred);
  709.             makercubeTopBack( 0.0,   PLANEY+0.06, 0.17,  0.1,  0.06, 0.08, colorred);
  710.  
  711.         glPopMatrix();
  712.  
  713.         if ((!monster.monsterIsDead) && (detail > 0))
  714.               {
  715.               glColor4fv(colorblack);
  716.               
  717.               drawShadow (0.0,   0.0,          0.2, 0.2);
  718.               drawShadow (0.2,   monster.rot2, 0.1, 0.15);
  719.               drawShadow (-0.2, -monster.rot2, 0.1, 0.15);
  720.               }
  721.  
  722.             /********/
  723.             /* tail */
  724.             /********/
  725.     
  726.             glRotatef(sin(counter * 0.15915)*10, 0, 1, 0); /* 1/(2 * pi) */
  727.  
  728.             glCallList(monsterSimpleTail);
  729.  
  730.             if (itsChristmas)
  731.                 {
  732.                 glPushMatrix();
  733.                     glTranslatef(-0.15,  PLANEY+0.85,  -0.45);
  734.                     glScalef(0.15,  0.15,  0.15);
  735.                     drawClosedCone(colorbeige, colorbrown, 1);
  736.                 glPopMatrix();
  737.    
  738.                 glPushMatrix();
  739.                     glTranslatef(0.0,  PLANEY+0.5,  -0.3);
  740.                     glScalef(1,  1.5,  1);
  741.                     glColor3fv(colorbeige);
  742.                     v[0] = v[1] = v[2] = 0;
  743.                     v[3] = 0.2;
  744.                     andysphdraw(v, 4);
  745.                 glPopMatrix();
  746.                 }
  747.  
  748.  
  749.     glPopMatrix();
  750.     }
  751.  
  752. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  753. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  754. /* Draw the Vapour                                               */
  755. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  756.  
  757. void drawVapour(struct monsterInfo monster, int itsChristmas, int detail)
  758.     {
  759.     register int i;
  760.     glPushMatrix();
  761.  
  762.     if (detail > 0)
  763.         glEnable(GL_BLEND);
  764.         
  765.     glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
  766.  
  767.     colorwhite2[0] = 1;
  768.     colorwhite2[1] = 1;
  769.     colorwhite2[2] = 1;
  770.  
  771.     if (monster.monsterIsDead)
  772.         {
  773.         if (detail <= 0)
  774.             {
  775.             colorwhite2[0] = 1 - monster.deadCount * 0.022;
  776.             colorwhite2[1] = 1 - monster.deadCount * 0.022;
  777.             colorwhite2[2] = 1 - monster.deadCount * 0.022;
  778.             }
  779.  
  780.         colorwhite2[3] = 1 - monster.deadCount * 0.022;
  781.         glColor4fv(colorwhite2);
  782.         }
  783.     else if (itsChristmas)
  784.         glColor4fv(colorsnowvapour);
  785.     else
  786.         glColor4fv(colorwhite); 
  787.  
  788.     if (detail == 0)
  789.         for(i = 0; i < (int) (MAXTRIBUTES/1.5); i++)
  790.             andysphdraw(monster.a[i], 0);
  791.     else
  792.         for(i=0; i<MAXTRIBUTES; i++)
  793.             andysphdraw(monster.a[i], 0);
  794.  
  795.     glDisable(GL_BLEND);
  796.  
  797.     glPopMatrix();
  798.     } 
  799.  
  800.  
  801.    
  802. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  803. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  804. /* draw Flutter                                                  */
  805. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  806.  
  807. void drawFlutter(struct monsterInfo monster, int counter,
  808.                 int itsChristmas, float offsetX, int thaView, int detail)
  809.     {
  810.     float rotAmt;
  811.     
  812.     rotAmt = sin(counter * 0.3183) * 15;
  813.     
  814.  
  815.     glPushMatrix();
  816.         glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
  817.  
  818.         /* shadow */
  819.  
  820.         if (!monster.monsterIsDead)
  821.             {
  822.             glPushAttrib(GL_DEPTH_BUFFER_BIT);
  823.             glPushAttrib(GL_COLOR_BUFFER_BIT);
  824.             
  825.             if (thaView == MONSTERVIEW)
  826.                 {
  827.                 if (detail > 0) 
  828.                     glEnable(GL_BLEND);          
  829.                 
  830.                 }
  831.     
  832.             glCallList(flutterShadow); 
  833.                 
  834.             glPopAttrib();
  835.             glPopAttrib();
  836.             }
  837.  
  838.    
  839.  
  840.         glPushMatrix();
  841.             glRotatef(offsetX * 10, 0, 0, 1);
  842.  
  843.             if (itsChristmas)
  844.                 glCallList(flutterXMas);                
  845.                 
  846.             glPushMatrix();
  847.                 glRotatef(monster.headVertRotate * 0.05, 1, 0, 0);
  848.  
  849.                 glCallList(flutterHead);
  850.             glPopMatrix();
  851.  
  852.             glCallList(flutterBody);
  853.     
  854.             glTranslatef(0, PLANEY+1.15, 0);
  855.  
  856.             glPushMatrix();
  857.                 glRotatef(  rotAmt, 0, 0, 1); /* 1/(2 * pi) */
  858.                 glCallList(flutterWing1);
  859.             glPopMatrix();
  860.             
  861.             glPushMatrix();
  862.                 glRotatef( - rotAmt, 0, 0, 1); /* 1/(2 * pi) */
  863.                 glCallList(flutterWing2);
  864.             glPopMatrix();
  865.  
  866.             
  867.         glPopMatrix();
  868.         
  869.     glPopMatrix();
  870.  
  871.     } 
  872.  
  873.  
  874.  
  875. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  876. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  877. /* draw Techs                                                    */
  878. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  879.  
  880. void drawTechs(struct monsterInfo monster, int detail)
  881.     {
  882.     glPushMatrix();
  883.  
  884.     glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
  885.  
  886.     if (monster.deadCount < 45)
  887.         {    
  888.         glPushMatrix();
  889.             glRotatef(0.1 * monster.headVertRotate, 1, 0, 0);
  890.             glCallList(techsHead);    
  891.         glPopMatrix();   
  892.  
  893.         glCallList(techsBody);
  894.         }
  895.     
  896.     if ((!monster.monsterIsDead) && (detail > 0))
  897.         {
  898.         glCallList(techsShadow);
  899.         }
  900.         
  901.     glPopMatrix();
  902.                     
  903.     if (monster.deadCount >= 45)
  904.         {
  905.         glPushMatrix();
  906.             glTranslatef(monster.timeDead * 0.05 + 0.2,  -monster.timeDead * 0.05,   monster.timeDead * 0.05);
  907.             glRotatef(monster.timeDead*10, 1, 0, 0);
  908.             glRotatef(monster.timeDead*15, 0, 1, 0);
  909.             makercube(0.0,    0, 0, 0.03, 0.25, 0.2, colorgrey2);
  910.             makercube(0.011,  0, 0, 0.02, 0.2, 0.15, colorblack);
  911.         glPopMatrix();
  912.  
  913.         glPushMatrix();
  914.             glTranslatef(-monster.timeDead * 0.05 - 0.2,  monster.timeDead * 0.05,   monster.timeDead * 0.05);
  915.             glRotatef(monster.timeDead*10, 1, 0, 0);
  916.             glRotatef(monster.timeDead*15, 0, 1, 0);
  917.             makercube( 0.0,   0, 0, 0.03, 0.25, 0.2, colorgrey2);
  918.             makercube(-0.011, 0, 0, 0.02, 0.2, 0.15, colorblack);
  919.         glPopMatrix();
  920.         }
  921.     }
  922.  
  923.  
  924. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  925. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  926. /* draw SIMPLE Techs                                             */
  927. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  928.  
  929. void drawSimpleTechs(struct monsterInfo monster, int detail)
  930.     {
  931.     glPushMatrix();
  932.  
  933.     glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
  934.  
  935.     if (monster.deadCount < 45)
  936.         {    
  937.         glPushMatrix();
  938.             glRotatef(0.1 * monster.headVertRotate, 1, 0, 0);
  939.             glCallList(techsSimpleHead);    
  940.         glPopMatrix();   
  941.  
  942.         glCallList(techsSimpleBody);
  943.         }
  944.     
  945.     if ((!monster.monsterIsDead) && (detail > 0))
  946.         {
  947.         glCallList(techsShadow);
  948.         }
  949.         
  950.     glPopMatrix();
  951.                     
  952.     }
  953.  
  954.   
  955. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  956. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  957. /* draw the energy typhoon hero                                  */
  958. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  959.  
  960. void drawHeroDude(int power, int counter,
  961.                 int mcount, int dCount, int detail)
  962.     {
  963.     float spheredat[4];
  964.     int ang;
  965.     int amount, amount2;
  966.     float dam;
  967.     float c1[4], c2[4], c3[4], c4[4], c5[4];
  968.     int sph;
  969.     
  970.     if (detail >= 2)
  971.         sph = 4;
  972.     else
  973.         sph = 3;
  974.  
  975.     c1[3] = c2[3] = c3[3] = c4[3] = c5[3] = 1;
  976.     dam = dCount * 0.075;
  977.     
  978.     c2[0] = (colorwhite[0] + dam) >= 1 ? 1 : (colorwhite[0] + dam);
  979.     c2[1] = (colorwhite[1] + dam) >= 1 ? 1 : (colorwhite[1] + dam);
  980.     c2[2] = (colorwhite[2] + dam) >= 1 ? 1 : (colorwhite[2] + dam);
  981.     
  982.     c1[0] = (colorwater[0] + dam) >= 1 ? 1 : (colorwater[0] + dam);
  983.     c1[1] = (colorwater[1] + dam) >= 1 ? 1 : (colorwater[1] + dam);
  984.     c1[2] = (colorwater[2] + dam) >= 1 ? 1 : (colorwater[2] + dam);
  985.  
  986.     c3[0] = (colorblack[0] + dam) >= 1 ? 1 : (colorblack[0] + dam);
  987.     c3[1] = (colorblack[1] + dam) >= 1 ? 1 : (colorblack[1] + dam);
  988.     c3[2] = (colorblack[2] + dam) >= 1 ? 1 : (colorblack[2] + dam);
  989.  
  990.     c4[0] = (colorgrey2[0] + dam) >= 1 ? 1 : (colorgrey2[0] + dam);
  991.     c4[1] = (colorgrey2[1] + dam) >= 1 ? 1 : (colorgrey2[1] + dam);
  992.     c4[2] = (colorgrey2[2] + dam) >= 1 ? 1 : (colorgrey2[2] + dam);
  993.  
  994.     c5[0] = (colorwater[0] + dam) >= 1 ? 1 : (colorwater[0] + dam);
  995.     c5[1] = (colorwater[1] + dam) >= 1 ? 1 : (colorwater[1] + dam);
  996.     c5[2] = (colorwater[2] + dam) >= 1 ? 1 : (colorwater[2] + dam);
  997.  
  998.     /********/
  999.     /* head */
  1000.     /********/
  1001.     
  1002.     glPushMatrix();
  1003.             glScalef(0.55,  1,  0.55);  
  1004.             glColor4fv(c4);
  1005.             spheredat[0] = 0;
  1006.             spheredat[1] = PLANEY+1.21;
  1007.             spheredat[2] = 0;
  1008.             spheredat[3] = 0.12;
  1009.             andysphdraw(spheredat, sph);
  1010.             
  1011.             if (power > 8)
  1012.                 makercube(.06, PLANEY+1.25, .075,  0.03, 0.015, 0.035, c3);
  1013.             else
  1014.                 makeitd(1, c3, .06, PLANEY+1.25, .075,  0.03, 0.015, 0.035);
  1015.  
  1016.             if (power > 5)          
  1017.                 makercube(-.06, PLANEY+1.25, .075,  0.03, 0.015, 0.035, c3);
  1018.             else
  1019.                 makeitd(0, c3, -.06, PLANEY+1.25, .075,  0.03, 0.015, 0.035);
  1020.                 
  1021.             if (power > 3)
  1022.                 makercube(0, PLANEY+1.16, .075,  0.03, 0.014, 0.035, c4);
  1023.             else
  1024.                 makeitd(1,  c4, 0, PLANEY+1.16, .075,  0.03, 0.014, 0.035);
  1025.             glColor4fv(c5);
  1026.             spheredat[2] = -0.01;
  1027.             andysphdraw(spheredat, sph);
  1028.     glPopMatrix();
  1029.  
  1030.  
  1031.     /********/
  1032.     /* neck */
  1033.     /********/
  1034.     
  1035.     if (power > 10)
  1036.         makercube(0, PLANEY+1.075, 0,  0.025, 0.025, 0.025, c2);
  1037.     else
  1038.         makeitd(1, c2, 0, PLANEY+1.075, 0,  0.025, 0.025, 0.025);
  1039.    
  1040.     /********/
  1041.     /* body */
  1042.     /********/
  1043.    
  1044.     if (power > 15)
  1045.         makercube(0, PLANEY+0.95, 0,  0.075, 0.1, 0.055, c1);
  1046.     else
  1047.         makeitd(0, c1, 0, PLANEY+0.95, 0,  0.075, 0.1, 0.055);
  1048.         
  1049.     if (power > 20)
  1050.         makercube(0, PLANEY+0.75, 0,  0.075, 0.1, 0.055, c2);
  1051.     else
  1052.         makeitd(0, c2, 0, PLANEY+0.75, 0,  0.075, 0.1, 0.055);
  1053.         
  1054.     if (power > 25)
  1055.         makercube(0, PLANEY+1.01, 0.055,  0.02, 0.05, 0.01, c2);
  1056.     else
  1057.         makeitd(1, c2, 0, PLANEY+1.01, 0.055,  0.02, 0.05, 0.01);
  1058.  
  1059.     /*************/
  1060.     /* shoulders */
  1061.     /*************/
  1062.  
  1063.     if (power > 30)
  1064.         makercube(0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05, c2);
  1065.     else
  1066.         makeitd(0, c2, 0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05);
  1067.         
  1068.     if (power > 35)
  1069.         makercube(-0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05, c2);
  1070.     else
  1071.         makeitd(1, c2, -0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05);
  1072.  
  1073.     /********/
  1074.     /* arms */
  1075.     /********/
  1076.  
  1077.     if (mcount > 30)
  1078.         amount = (40 - mcount) * 9;
  1079.     else if (mcount > 10)
  1080.         amount = 90;
  1081.     else
  1082.         amount = mcount * 9;
  1083.     
  1084.     ang = (int) amount * 10;
  1085.  
  1086.     glPushMatrix();
  1087.         glRotatef(.1*(-ang), 1, 0, 0);
  1088.  
  1089.         if (power > 40)
  1090.             makercube(0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025, c1);
  1091.         else
  1092.             makeitd(1, c1, 0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025);
  1093.  
  1094.         glPushMatrix();
  1095.             glTranslatef(0.13,  PLANEY+0.75,  0);
  1096.         
  1097.             if (power > 45)
  1098.                 makercube(0, -0.09, 0,  0.024, 0.11, 0.024, c2);
  1099.             else
  1100.                 makeitd(0, c2, 0, -0.09, 0,  0.024, 0.11, 0.024);
  1101.             
  1102.             if (power > 50)
  1103.                 makercube(0, -0.19, 0,  0.03, 0.03, 0.028, c1);
  1104.             else
  1105.                 makeitd(1, c1, 0, -0.19, 0,  0.03, 0.03, 0.028);
  1106.         glPopMatrix();
  1107.     glPopMatrix();
  1108.  
  1109.     glPushMatrix();
  1110.         glRotatef(.1*(-ang), 1, 0, 0);
  1111.  
  1112.         if (power > 55)
  1113.             makercube(-0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025, c1);
  1114.         else
  1115.             makeitd(0, c1, -0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025);
  1116.    
  1117.         glPushMatrix();
  1118.             glTranslatef(-0.13,  PLANEY+0.75,  0);
  1119.             
  1120.             if (power > 60)
  1121.                 makercube(0, -0.09, 0,  0.024, 0.11, 0.024, c2);
  1122.             else
  1123.                 makeitd(0, c2, 0, -0.09, 0,  0.024, 0.11, 0.024);
  1124.             
  1125.             if (power > 65)
  1126.                 makercube(0, -0.19, 0,  0.03, 0.03, 0.028, c1);
  1127.             else
  1128.                 makeitd(1, c1, 0, -0.19, 0,  0.03, 0.03, 0.028);
  1129.         glPopMatrix();
  1130.     glPopMatrix();
  1131.     
  1132.     /********/
  1133.     /* legs */
  1134.     /********/
  1135.  
  1136.     amount = (counter * 100) % 2400;
  1137.     if (amount < 1200)
  1138.         amount2 = 300 + amount;
  1139.     else
  1140.         amount2 = 900 + amount;
  1141.  
  1142.     ang = (int) (cos(BIG_DEG_TO_RAD * amount2) * RAD_TO_SMALL_DEG * 2.5);
  1143.  
  1144.     glPushMatrix();
  1145.         glTranslatef(0.04,  PLANEY+0.65,  0);
  1146.         glRotatef(.1*(ang ), 1, 0, 0);
  1147.         
  1148.         if (power > 70)
  1149.             makercube(0, -0.12, 0,  0.035, 0.13, 0.03, c2);
  1150.         else
  1151.             makeitd(0, c2, 0, -0.12, 0,  0.035, 0.13, 0.03);
  1152.             
  1153.         if (power > 75) 
  1154.             makercube(0, -.35, 0,  0.024, 0.2, 0.029, c1);
  1155.         else
  1156.             makeitd(1, c1, 0, -.35, 0,  0.024, 0.2, 0.029);
  1157.             
  1158.         if (power > 80)
  1159.             makercube(0, -.59, +0.025,  0.026, 0.04, 0.075, c2);
  1160.         else
  1161.             makeitd(0, c2, 0, -.59, +0.025,  0.026, 0.04, 0.075);
  1162.     glPopMatrix();
  1163.     
  1164.     glPushMatrix();
  1165.         glTranslatef(-0.04,  PLANEY+0.65,  0);
  1166.         glRotatef(.1*(-ang), 1, 0, 0);
  1167.         
  1168.         if (power > 85)
  1169.             makercube(0, -0.12, 0,  0.035, 0.13, 0.03, c2);
  1170.         else
  1171.             makeitd(1, c2, 0, -0.12, 0,  0.035, 0.13, 0.03);
  1172.             
  1173.         if (power > 90)
  1174.             makercube(0, -.35, 0,  0.024, 0.2, 0.029, c1);
  1175.         else
  1176.             makeitd(0, c1, 0, -.35, 0,  0.024, 0.2, 0.029);
  1177.             
  1178.         if (power > 95)
  1179.             makercube(0, -.59, +0.025,  0.026, 0.04, 0.075, c2);
  1180.         else
  1181.             makeitd(1, c2, 0, -.59, +0.025,  0.026, 0.04, 0.075);
  1182.     glPopMatrix();
  1183.     
  1184.     }
  1185.  
  1186. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1187. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1188. /* draw the energy beam hero                                     */
  1189. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1190.  
  1191. void drawHeroDude2(int power, int counter,
  1192.                     int mcount, int dCount, int detail)
  1193.     {
  1194.     float spheredat[4];
  1195.     int ang;
  1196.     int amount, amount2;
  1197.     float dam;
  1198.     float c1[4], c2[4], c3[4], c4[4], c5[4];
  1199.     int sph;
  1200.     
  1201.  
  1202.     if (detail >= 2)
  1203.         sph=4;
  1204.     else
  1205.         sph=3 ;
  1206.  
  1207.  
  1208.     c1[3] = c2[3] = c3[3] = c4[3] = c5[3] = 1;
  1209.     dam = dCount * 0.075;
  1210.  
  1211.     c1[0] = (colorwhite[0] + dam) >= 1 ? 1 : (colorwhite[0] + dam);
  1212.     c1[1] = (colorwhite[1] + dam) >= 1 ? 1 : (colorwhite[1] + dam);
  1213.     c1[2] = (colorwhite[2] + dam) >= 1 ? 1 : (colorwhite[2] + dam);
  1214.     
  1215.     c2[0] = (colorred[0] + dam) >= 1 ? 1 : (colorred[0] + dam);
  1216.     c2[1] = (colorred[1] + dam) >= 1 ? 1 : (colorred[1] + dam);
  1217.     c2[2] = (colorred[2] + dam) >= 1 ? 1 : (colorred[2] + dam);
  1218.  
  1219.     c3[0] = (colorblack[0] + dam) >= 1 ? 1 : (colorblack[0] + dam);
  1220.     c3[1] = (colorblack[1] + dam) >= 1 ? 1 : (colorblack[1] + dam);
  1221.     c3[2] = (colorblack[2] + dam) >= 1 ? 1 : (colorblack[2] + dam);
  1222.  
  1223.     c4[0] = (colorgrey2[0] + dam) >= 1 ? 1 : (colorgrey2[0] + dam);
  1224.     c4[1] = (colorgrey2[1] + dam) >= 1 ? 1 : (colorgrey2[1] + dam);
  1225.     c4[2] = (colorgrey2[2] + dam) >= 1 ? 1 : (colorgrey2[2] + dam);
  1226.  
  1227.     c5[0] = (colorred3[0] + dam) >= 1 ? 1 : (colorred3[0] + dam);
  1228.     c5[1] = (colorred3[1] + dam) >= 1 ? 1 : (colorred3[1] + dam);
  1229.     c5[2] = (colorred3[2] + dam) >= 1 ? 1 : (colorred3[2] + dam);
  1230.  
  1231.     /********/
  1232.     /* head */
  1233.     /********/
  1234.     
  1235.     glPushMatrix();
  1236.             glScalef(0.55, 1,   0.55);  
  1237.             glColor4fv(c4);
  1238.             spheredat[0] = 0;
  1239.             spheredat[1] = PLANEY+1.21;
  1240.             spheredat[2] = 0;
  1241.             spheredat[3] = 0.12;
  1242.             andysphdraw(spheredat, sph);
  1243.             
  1244.             if (power > 8)
  1245.                 makercube(.06, PLANEY+1.25, .075,  0.03, 0.015, 0.035, c3);
  1246.             else
  1247.                 makeitd(1, c3, .06, PLANEY+1.25, .075,  0.03, 0.015, 0.035);
  1248.  
  1249.             if (power > 5)          
  1250.                 makercube(-.06, PLANEY+1.25, .075,  0.03, 0.015, 0.035, c3);
  1251.             else
  1252.                 makeitd(0, c3, -.06, PLANEY+1.25, .075,  0.03, 0.015, 0.035);
  1253.                 
  1254.             if (power > 3)
  1255.                 makercube(0, PLANEY+1.16, .075,  0.03, 0.014, 0.035, c4);
  1256.             else
  1257.                 makeitd(1,  c4, 0, PLANEY+1.16, .075,  0.03, 0.014, 0.035);
  1258.             glColor4fv(c5);
  1259.             spheredat[2] = -0.01;
  1260.             andysphdraw(spheredat, sph);
  1261.     glPopMatrix();
  1262.  
  1263.     /********/
  1264.     /* neck */
  1265.     /********/
  1266.     
  1267.     if (power > 10)
  1268.         makercube(0, PLANEY+1.075, 0,  0.025, 0.025, 0.025, c2);
  1269.     else
  1270.         makeitd(1, c2, 0, PLANEY+1.075, 0,  0.025, 0.025, 0.025);
  1271.    
  1272.     /********/
  1273.     /* body */
  1274.     /********/
  1275.    
  1276.     if (power > 15)
  1277.         makercube(0, PLANEY+0.95, 0,  0.075, 0.1, 0.055, c1);
  1278.     else
  1279.         makeitd(0, c1, 0, PLANEY+0.95, 0,  0.075, 0.1, 0.055);
  1280.         
  1281.     if (power > 20)
  1282.         makercube(0, PLANEY+0.75, 0,  0.075, 0.1, 0.055, c2);
  1283.     else
  1284.         makeitd(0, c2, 0, PLANEY+0.75, 0,  0.075, 0.1, 0.055);
  1285.         
  1286.     if (power > 25)
  1287.         makercube(0, PLANEY+1.01, 0.055,  0.02, 0.05, 0.01, c2);
  1288.     else
  1289.         makeitd(1, c2, 0, PLANEY+1.01, 0.055,  0.02, 0.05, 0.01);
  1290.  
  1291.     /*************/
  1292.     /* shoulders */
  1293.     /*************/
  1294.  
  1295.     if (power > 30)
  1296.         makercube(0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05, c2);
  1297.     else
  1298.         makeitd(0, c2, 0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05);
  1299.         
  1300.     if (power > 35)
  1301.         makercube(-0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05, c2);
  1302.     else
  1303.         makeitd(1, c2, -0.075, PLANEY+1.0, 0,  0.075, 0.051, 0.05);
  1304.  
  1305.     /********/
  1306.     /* arms */
  1307.     /********/
  1308.  
  1309.     if (mcount > 30)
  1310.         amount = (40 - mcount) * 9;
  1311.     else if (mcount > 10)
  1312.         amount = 90;
  1313.     else
  1314.         amount = mcount * 9;
  1315.     
  1316.     ang = (int) amount * 10;
  1317.  
  1318.     if (power > 40)
  1319.         makercube(0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025, c1);
  1320.     else
  1321.         makeitd(1, c1, 0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025);
  1322.  
  1323.     glPushMatrix();
  1324.         glTranslatef(0.13,  PLANEY+0.75,  0);
  1325.         
  1326.         if (power > 45)
  1327.             makercube(0, -0.09, 0,  0.024, 0.11, 0.024, c2);
  1328.         else
  1329.             makeitd(0, c2, 0, -0.09, 0,  0.024, 0.11, 0.024);
  1330.             
  1331.         if (power > 50)
  1332.             makercube(0, -0.19, 0,  0.03, 0.03, 0.028, c1);
  1333.         else
  1334.             makeitd(1, c1, 0, -0.19, 0,  0.03, 0.03, 0.028);
  1335.     glPopMatrix();
  1336.  
  1337.  
  1338.     glPushMatrix();
  1339.         glRotatef(.1*(-ang/2 ), 1, 0, 0);
  1340.  
  1341.         if (power > 55)
  1342.             makercube(-0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025, c1);
  1343.         else
  1344.             makeitd(0, c1, -0.13, PLANEY+0.875, 0,  0.025, 0.125, 0.025);
  1345.    
  1346.         glPushMatrix();
  1347.             glTranslatef(-0.13,  PLANEY+0.75,  0);
  1348.             glRotatef(.1*(ang ), 0, 0, 1);
  1349.             
  1350.             if (power > 60)
  1351.                 makercube(0, -0.09, 0,  0.024, 0.11, 0.024, c2);
  1352.             else
  1353.                 makeitd(0, c2, 0, -0.09, 0,  0.024, 0.11, 0.024);
  1354.             
  1355.             if (power > 65)
  1356.                 makercube(0, -0.19, 0,  0.03, 0.03, 0.028, c1);
  1357.             else
  1358.                 makeitd(1, c1, 0, -0.19, 0,  0.03, 0.03, 0.028);
  1359.         glPopMatrix();
  1360.     glPopMatrix();
  1361.     
  1362.     /********/
  1363.     /* legs */
  1364.     /********/
  1365.  
  1366.     amount = (counter *100) % 2400;
  1367.     if (amount < 1200)
  1368.         amount2 = 300 + amount;
  1369.     else
  1370.         amount2 = 900 + amount;
  1371.  
  1372.     ang = (int) (cos(BIG_DEG_TO_RAD * amount2) * RAD_TO_SMALL_DEG * 2.5);
  1373.  
  1374.     glPushMatrix();
  1375.         glTranslatef(0.04,  PLANEY+0.65,  0);
  1376.         glRotatef(.1*(ang ), 1, 0, 0);
  1377.         
  1378.         if (power > 70)
  1379.             makercube(0, -0.12, 0,  0.035, 0.13, 0.03, c2);
  1380.         else
  1381.             makeitd(0, c2, 0, -0.12, 0,  0.035, 0.13, 0.03);
  1382.             
  1383.         if (power > 75) 
  1384.             makercube(0, -.35, 0,  0.024, 0.2, 0.029, c1);
  1385.         else
  1386.             makeitd(1, c1, 0, -.35, 0,  0.024, 0.2, 0.029);
  1387.             
  1388.         if (power > 80)
  1389.             makercube(0, -.59, +0.025,  0.026, 0.04, 0.075, c2);
  1390.         else
  1391.             makeitd(0, c2, 0, -.59, +0.025,  0.026, 0.04, 0.075);
  1392.     glPopMatrix();
  1393.     
  1394.     glPushMatrix();
  1395.         glTranslatef(-0.04,  PLANEY+0.65,  0);
  1396.         glRotatef(.1*(-ang), 1, 0, 0);
  1397.         
  1398.         if (power > 85)
  1399.             makercube(0, -0.12, 0,  0.035, 0.13, 0.03, c2);
  1400.         else
  1401.             makeitd(1, c2, 0, -0.12, 0,  0.035, 0.13, 0.03);
  1402.             
  1403.         if (power > 90)
  1404.             makercube(0, -.35, 0,  0.024, 0.2, 0.029, c1);
  1405.         else
  1406.             makeitd(0, c1, 0, -.35, 0,  0.024, 0.2, 0.029);
  1407.             
  1408.         if (power > 95)
  1409.             makercube(0, -.59, +0.025,  0.026, 0.04, 0.075, c2);
  1410.         else
  1411.             makeitd(1, c2, 0, -.59, +0.025,  0.026, 0.04, 0.075);
  1412.     glPopMatrix();
  1413.     
  1414.     }
  1415.  
  1416. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1417. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1418. /* draw MechaGoogelon                                            */
  1419. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1420.  
  1421.  
  1422. void drawMechaMonster(int dam, int counter, int detail)
  1423.     {
  1424.     if (dam > 48)
  1425.        makercube(0.2, PLANEY+0.7, 0,  0.05, 0.05, 0.15, colorblue);
  1426.     else
  1427.        makeitd(1, colorblue, 0.2, PLANEY+0.7, 0,  0.05, 0.05, 0.15);
  1428.  
  1429.     if (dam > 45)
  1430.        makercube(-0.2, PLANEY+0.7, 0,  0.05, 0.05, 0.15, colorblue);
  1431.     else
  1432.        makeitd(0, colorblue, -0.2, PLANEY+0.7, 0,  0.05, 0.05, 0.15);
  1433.  
  1434.     /**************************/
  1435.     /* legs, feet of one side */
  1436.     /**************************/
  1437.  
  1438.     if (dam > 43)
  1439.        makercube(0.2, PLANEY+0.2, 0,  0.12, 0.2, 0.1, colorgrey2);
  1440.     else
  1441.        makeitd(0, colorgrey2, 0.2, PLANEY+0.2, 0,  0.12, 0.2, 0.1);
  1442.  
  1443.     if (dam > 40)
  1444.        makercube(0.2, PLANEY+0.06, 0.1,  0.1, 0.06, 0.15, colorwhite);
  1445.     else
  1446.        makeitd(1, colorwhite, 0.2, PLANEY+0.06, 0.1,  0.1, 0.06, 0.15);
  1447.  
  1448.     /****************************/
  1449.     /* legs, feet of other side */
  1450.     /****************************/
  1451.  
  1452.     if (dam > 38)
  1453.        makercube(-0.2, PLANEY+0.2, 0,  0.12, 0.2, 0.1, colorgrey2);
  1454.     else
  1455.         makeitd(1, colorgrey2, -0.2, PLANEY+0.2, 0,  0.12, 0.2, 0.1);
  1456.  
  1457.     if (dam > 35)
  1458.         makercube(-0.2, PLANEY+0.06, 0.1,  0.1, 0.06, 0.15, colorwhite);
  1459.     else
  1460.         makeitd(0, colorwhite, -0.2, PLANEY+0.06, 0.1,  0.1, 0.06, 0.15);
  1461.   
  1462.     /********/
  1463.     /* tail */
  1464.     /********/
  1465.  
  1466.     if (dam > 30)
  1467.         {
  1468.         makercube(0, PLANEY+0.2, -0.2,  0.1, 0.15, 0.2, colorwhite);
  1469.         makercube(0, PLANEY+0.1, -0.4,  0.08, 0.1, 0.2, colorgrey2);
  1470.         }
  1471.     else
  1472.         {
  1473.         makeitd(0, colorwhite, 0, PLANEY+0.2, -0.2,  0.1, 0.15, 0.2);
  1474.         makeitd(1, colorgrey2, 0, PLANEY+0.1, -0.4,  0.08, 0.1, 0.2);
  1475.         }
  1476.  
  1477.     glColor4fv(colorblack);
  1478.  
  1479.     if (detail > 0)
  1480.         {    
  1481.         drawShadow (0,  -0.2,  0.1,  0.2);
  1482.         drawShadow (0,  -0.4,  0.08,  0.2);
  1483.         }
  1484.     
  1485.     /********/
  1486.     /* head */
  1487.     /********/
  1488.  
  1489.     if (dam > 26)
  1490.         makercube(0, PLANEY + 1.15, 0,  0.25, 0.15, 0.12, colorwhite);
  1491.     else
  1492.         makeitd(0, colorwhite, 0, PLANEY + 1.15, 0,  0.25, 0.15, 0.12);
  1493.  
  1494.     makeitPyr(2, colorwhite, 0, PLANEY + 1.15, -.24,  0.25, 0.15, 0.12);
  1495.  
  1496.     if (dam > 22)
  1497.         makercube(0, PLANEY + 1.15, -0.24,  0.13, 0.08, 0.1, colorgrey2);
  1498.     else
  1499.         makeitd(1, colorgrey2, 0, PLANEY + 1.15, -0.24,  0.13, 0.08, 0.1);
  1500.  
  1501.     /*******/
  1502.     /* eye */
  1503.     /*******/
  1504.  
  1505.     if (dam > 18)
  1506.         makercube(0, PLANEY + 1.20, 0.1, 0.15, 0.06, 0.05, colorblack);
  1507.     else
  1508.         makeitd(1, colorblack,  0, PLANEY + 1.20, 0.1, 0.15, 0.06, 0.05);
  1509.  
  1510.     if (dam > 14)
  1511.        makercube(sin((counter % 20) * 0.314) * 0.14, PLANEY + 1.20, 0.14,  0.04, 0.04, 0.04, colorred);
  1512.     else
  1513.        makeitd(0, colorred, sin((counter % 20) * 0.314) * 0.14, PLANEY + 1.20, 0.14,  0.04, 0.04, 0.04);
  1514.  
  1515.     /********/
  1516.     /* body */
  1517.     /********/
  1518.  
  1519.     if (dam > 10)
  1520.        makercube(0, PLANEY + 0.9, 0,  0.1, 0.2, 0.1, colorgrey2);
  1521.     else
  1522.        makeitd(0, colorgrey2, 0, PLANEY + 0.9, 0,  0.1, 0.2, 0.1);
  1523.  
  1524.  
  1525.     if (dam > 5)
  1526.        makercube(0, PLANEY + 0.5, 0.2, 0.1, 0.15, 0.05, colorgrey1);
  1527.     else
  1528.        makeitd(1, colorgrey1, 0, PLANEY + 0.5, 0.2, 0.1, 0.15, 0.05);
  1529.  
  1530.  
  1531.     if (dam > 0)
  1532.        makercube(0, PLANEY + 0.5, 0, 0.2, 0.3, 0.2, colorwhite);
  1533.     else
  1534.        makeitd(0, colorwhite, 0, PLANEY + 0.5, 0, 0.2, 0.3, 0.2);
  1535.  
  1536.     glColor4fv(colorblack);
  1537.  
  1538.     if (detail > 0)    
  1539.         drawShadow (0,  0,  0.2,  0.2);
  1540.     }
  1541.  
  1542. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1543. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1544. /* draw a window on the negative z side of a building            */
  1545. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1546.  
  1547. void wzminus(float x,  float y,  float z,  float wx,  float wy)
  1548.     {
  1549.     float v[3];
  1550.  
  1551.     v[2] = z;
  1552.  
  1553.     glBegin(GL_QUADS);
  1554.         v[0] = x-wx; v[1] = y-wy;   
  1555.         glVertex3fv(v);
  1556.  
  1557.         v[1] = y+wy;
  1558.         glVertex3fv(v);
  1559.  
  1560.         v[0] = x+wx;
  1561.         glVertex3fv(v);
  1562.  
  1563.         v[1] = y-wy;
  1564.         glVertex3fv(v);
  1565.     glEnd();
  1566.     }
  1567.  
  1568. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1569. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1570. /* draw a window on the positive z side of a building            */
  1571. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1572.    
  1573. void wzplus(float x,  float y,  float z,  float wx,  float wy)
  1574.     {
  1575.     float v[3];
  1576.  
  1577.     v[2] = z;
  1578.  
  1579.     glBegin(GL_QUADS);
  1580.         v[0] = x+wx; v[1] = y-wy;
  1581.         glVertex3fv(v);
  1582.  
  1583.         v[1] = y+wy;
  1584.         glVertex3fv(v);
  1585.  
  1586.         v[0] = x-wx;
  1587.         glVertex3fv(v);
  1588.  
  1589.         v[1] = y-wy;
  1590.         glVertex3fv(v);
  1591.     glEnd();
  1592.     }
  1593.  
  1594. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1595. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1596. /* draw a window on the positive x side of a building            */
  1597. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1598.  
  1599. void wxplus(float x,  float y,  float z,  float wy,  float wz)
  1600.     {
  1601.     float v[3];
  1602.  
  1603.     v[0] = x;
  1604.     
  1605.     glBegin(GL_QUADS);
  1606.         v[1] = y+wy;   v[2] = z-wz;
  1607.         glVertex3fv(v);
  1608.  
  1609.         v[2] = z+wz;
  1610.         glVertex3fv(v);
  1611.  
  1612.         v[1] = y-wy;
  1613.         glVertex3fv(v);
  1614.  
  1615.         v[2] = z-wz;
  1616.         glVertex3fv(v);
  1617.     glEnd();
  1618.     }
  1619.  
  1620. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1621. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1622. /* draw a window on the negative x side of a building            */
  1623. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1624.  
  1625. void wxminus(float x,  float y,  float z,  float wy,  float wz)
  1626.     {
  1627.     float v[3];
  1628.  
  1629.     v[0] = x;
  1630.  
  1631.     glBegin(GL_QUADS);
  1632.         v[1] = y-wy;   v[2] = z-wz;
  1633.         glVertex3fv(v);
  1634.  
  1635.         v[2] = z+wz;
  1636.         glVertex3fv(v);
  1637.  
  1638.         v[1] = y+wy;
  1639.         glVertex3fv(v);
  1640.  
  1641.         v[2] = z-wz;
  1642.         glVertex3fv(v);
  1643.     glEnd();
  1644.     }
  1645.  
  1646.  
  1647. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1648. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1649. /* draw generic square building                                  */
  1650. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1651.  
  1652. void drawBuilding0(float * colour, int detail)
  1653.     {
  1654.     makercubenobtm(0.0, 0.4, 0.0, 0.3, 0.4, 0.3, colour);
  1655.     if (detail > 0)
  1656.         glCallList(genericWindows);
  1657.     }
  1658.  
  1659.  
  1660. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1661. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1662. /* draw generic fast food resteraunt                             */
  1663. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1664.    
  1665. void drawBuilding6(int counter, float * c1,  float * c2, int detail)
  1666.     {
  1667.     makercubenobtmnotop(  0,  .2, 0,  .3, .2, .35, c1);
  1668.     makeitPyr(1, c2,  0,  .5, 0,  .35, .1, .45);
  1669.  
  1670.     makercubenobtm(  .38,  .25, 0.1,  .01, .25, .015, colorgrey2);
  1671.     
  1672.     glPushMatrix();
  1673.     glTranslatef(.38,   .6,  0.1);
  1674.         glRotatef((counter*15) % 360, 0, 1, 0);
  1675.         makercube(0.0, 0.0, 0.0, 0.01,  0.1,  0.14, c2);
  1676.         makercube(0.0, 0.0, 0.0, 0.013, 0.07, 0.11, c1);
  1677.     glPopMatrix();
  1678.  
  1679.     /* windows */
  1680.     
  1681.     if (detail > 0)
  1682.         {
  1683.         glColor3fv(colorblack);
  1684.     
  1685.         wxplus(0.303, 0.15, -0.15, 0.15,  0.05);
  1686.  
  1687.         wxplus(0.303, 0.2,   0.15, 0.075, 0.075);
  1688.     
  1689.         wzminus(-0.15, 0.2, -0.352, 0.075, 0.075);
  1690.         wzplus( -0.15, 0.2,  0.352, 0.075, 0.075);
  1691.         wzplus(  0.15, 0.2,  0.352, 0.075, 0.075);
  1692.         wzminus( 0.15, 0.2, -0.352, 0.075, 0.075);
  1693.         }
  1694.     }
  1695.  
  1696.  
  1697. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1698. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1699. /* draw warehouse / hanger                                       */
  1700. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1701.  
  1702. void drawBuilding8(float * c1,  float * c2, int detail)
  1703.     {
  1704.     makercubenobtmnotop(0,  .2, 0,  .35, .2, .3, c1);
  1705.     makeitPyr(4, c2,  0,  .5, 0,  .35, .1, .3);
  1706.  
  1707.     /* windows */
  1708.     
  1709.     if (detail > 0)    
  1710.         {
  1711.         glColor3fv(colorblack);
  1712.     
  1713.         wzminus(0.0, 0.15, -0.303, 0.25, 0.15);
  1714.         wzplus( 0.0, 0.15,  0.303, 0.25, 0.15);
  1715.         }
  1716.     }
  1717.  
  1718. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1719. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1720. /* draw cooling towers                                           */
  1721. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1722.  
  1723. void drawCoolingTower(int detail)
  1724.     {
  1725.     GLUquadricObj *qobj;
  1726.  
  1727.     glPushMatrix();
  1728.         glTranslatef(-0.3,  0.5,  -0.3);
  1729.         glScalef(0.3,  0.5,  0.3);
  1730.         
  1731.         drawClosedCylinder(colorgrey3,  colorwhite,  0, detail);
  1732.             
  1733.     glPopMatrix();
  1734.  
  1735.     if (detail >= 0)
  1736.         {
  1737.         glPushMatrix();
  1738.             glColor3fv(colorblack);
  1739.             glTranslatef(0.0,  0.9,  0.0);
  1740.             glRotatef(-90, 1, 0, 0);
  1741.             
  1742.             qobj = gluNewQuadric();
  1743.             gluDisk( qobj, 0.,  0.28, 32, 1);
  1744.             gluDeleteQuadric(qobj);
  1745.     
  1746.         glPopMatrix();
  1747.         }
  1748.     }
  1749.  
  1750. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1751. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1752. /* draw factory smokestacks                                      */
  1753. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1754.  
  1755. void drawBuilding11(int detail)
  1756.     {
  1757.     makercubenobtm(  0,  .05, 0,  .3, .05, .3, colorgrey1);
  1758.  
  1759.     glPushMatrix();
  1760.         glTranslatef(-.25,  .8,  -.1);
  1761.         glScalef(.1,  .8,  .1);
  1762.         drawClosedCylinder(colorgrey2,  colorgrey3,  0, detail);
  1763.     glPopMatrix();
  1764.  
  1765.     glPushMatrix();
  1766.         glTranslatef(.05,  .8,  -.1);
  1767.         glScalef(.1,  .8,  .1);
  1768.         drawClosedCylinder(colorgrey2,  colorgrey3,  0, detail);
  1769.     glPopMatrix();
  1770.     }
  1771.  
  1772.  
  1773. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1774. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1775. /* draw strip-mall store                                         */
  1776. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1777.  
  1778. void drawBuilding15(float * buildingColour,  float * awningColour, int detail)
  1779.     {
  1780.     makeitPyr(13, awningColour,  +.1,  .54, 0,  .3, .25, .297);
  1781.  
  1782.     makercubenobtm(  -.1,  .4, 0,  .3, .4, .3, buildingColour);
  1783.  
  1784.     if (detail > 0)
  1785.         {
  1786.         glColor3fv(colorblack);
  1787.     
  1788.         wxplus(0.203,  .15,  -.15,  .15,  .05);
  1789.         wxminus(-0.403,  .15,  -.15,  .15,  .05);
  1790.  
  1791.         wxplus(0.203,  .15,  .10,  .08,  .12);
  1792.         }
  1793.     }
  1794.  
  1795.  
  1796. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1797. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1798. /* draw office building                                          */
  1799. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1800.  
  1801. void drawBuilding22(float * color)
  1802.     {
  1803.     makercubenobtm(0,  .75, 0,  .3, .75, .3, color);    
  1804.     makercubenobtmnotop(0,  .4, 0,  .307, .1, .307, colorblack);
  1805.     makercubenobtmnotop(0,  .8, 0,  .307, .1, .307, colorblack);
  1806.     makercubenobtmnotop(0,  1.2, 0,  .307, .1, .307, colorblack);
  1807.     }
  1808.  
  1809. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1810. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1811. /* draw smaller office building                                   */
  1812. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1813.  
  1814. void drawBuilding34(float * color)
  1815.     {
  1816.     makercubenobtm(0,  .3, 0,  .3, .3, .3, color);    
  1817.     makercubenobtmnotop(0,  .4, 0,  .307, .1, .307, colorblack);
  1818.     }
  1819.  
  1820. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1821. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1822. /* draw small office building                                    */
  1823. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1824.  
  1825. void drawBuilding36(float * color)
  1826.     {
  1827.     makercubenobtm(0,  .5, 0,  .3, .5, .3, color);    
  1828.     makercubenobtmnotop(0,  .4, 0,  .307, .1, .307, colorblack);
  1829.     makercubenobtmnotop(0,  .8, 0,  .307, .1, .307, colorblack);
  1830.     }
  1831.  
  1832. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1833. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1834. /* draw office building with sign                                */
  1835. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1836.  
  1837. void drawBuilding37(float * color, int detail)
  1838.     {
  1839.     static float tv1[2] = {0,1};
  1840.     static float tv2[2] = {1,1};
  1841.     static float tv3[2] = {1,0};
  1842.     static float tv4[2] = {0,0};
  1843.  
  1844.     static float vec1[3]={0,1,0};
  1845.     static float vec2[3]={1,1,0};
  1846.     static float vec3[3]={1,0,0};
  1847.     static float vec4[3]={0,0,0};
  1848.  
  1849.     makercubenobtm(0,  .75, 0,  .3, .75, .3, color);    
  1850.     makercubenobtmnotop(0,  .4, 0,  .307, .1, .307, colorblack);
  1851.     makercubenobtmnotop(0,  .8, 0,  .307, .1, .307, colorblack);
  1852.     makercubenobtmnotop(0, 1.2, -0.01,  .307, .1, .307, colorblack);
  1853.     
  1854.     glPushMatrix();
  1855.     glColor4fv(colorwhite);
  1856.  
  1857.     if ((detail >= 2) && (officeLogoData != NULL))
  1858.         {       
  1859.         glCallList(officeLogo);
  1860.         glEnable(GL_TEXTURE_2D);
  1861.         }       
  1862.         
  1863.     glTranslatef(0.25, 1.1, 0.31);
  1864.     glScalef(0.5, 0.3,  0.01);
  1865.  
  1866.     glRotatef(180, 0, 1, 0);
  1867.  
  1868.     glBegin(GL_QUADS);
  1869.  
  1870.     if ((detail >= 2) && (picleft != NULL))
  1871.         {       
  1872.         glTexCoord2fv(tv1);
  1873.         glVertex3fv(vec1);
  1874.         
  1875.         glTexCoord2fv(tv2);
  1876.         glVertex3fv(vec2);
  1877.         
  1878.         glTexCoord2fv(tv3);
  1879.         glVertex3fv(vec3);
  1880.         
  1881.         glTexCoord2fv(tv4);
  1882.         glVertex3fv(vec4);
  1883.         }
  1884.     else
  1885.         {
  1886.         glVertex3fv(vec1);
  1887.         glVertex3fv(vec2);
  1888.         glVertex3fv(vec3);
  1889.         glVertex3fv(vec4);
  1890.         } 
  1891.               
  1892.     glEnd();
  1893.  
  1894.     glDisable(GL_TEXTURE_2D);
  1895.  
  1896.     glPopMatrix();
  1897.     }
  1898.  
  1899. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1900. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1901. /* draw satellite dish                                           */
  1902. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1903.  
  1904. void drawBuilding25()
  1905.     {
  1906.     long backNow;
  1907.     GLUquadricObj *qobj;
  1908.     
  1909.     /******************/
  1910.     /* satellite dish */
  1911.     /******************/
  1912.  
  1913.     float satSphere[4] = {0, 0.4, 0, 0.075};
  1914.  
  1915.     float sat0[3] = { 0.0,  0.35, 0.0};
  1916.     float sat1[3] = { 0.0,  0.0,  0.35};
  1917.     float sat2[3] = { 0.0, -0.35, 0.0};
  1918.     float sat3[3] = { 0.35, 0.0,  0.0};
  1919.     float sat4[3] = {-0.35, 0.0,  0.0};
  1920.  
  1921.     GLfloat lineWidthNow;
  1922.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  1923.   
  1924.     backNow = glIsEnabled(GL_CULL_FACE);
  1925.  
  1926.     /* shadow */
  1927.     
  1928.     glColor3fv(colorblack);
  1929.     
  1930.     glPushMatrix();
  1931.         glTranslatef(0,  0,   0);
  1932.         glRotatef(-90, 1, 0, 0);
  1933.  
  1934.         qobj = gluNewQuadric();
  1935.         gluDisk( qobj, 0.,   0.3, 32, 1);
  1936.         gluDeleteQuadric(qobj);
  1937.  
  1938.     glPopMatrix();
  1939.  
  1940.     /* support post */
  1941.     
  1942.     makercubenobtm(  0,  .2, 0,  .05, .2, .05, colorwhite);
  1943.  
  1944.         
  1945.     glColor3fv(colorgrey2);
  1946.     andysphdraw(satSphere, 4);
  1947.     
  1948.     /* if line widths are integral Mesa chokes in a large window */
  1949.     glLineWidth(3.01);    
  1950.     glColor3fv(colorwhite);
  1951.     
  1952.     glPushMatrix();
  1953.         glDisable(GL_CULL_FACE);
  1954.         
  1955.         glTranslatef(0,  .4,   0);
  1956.         glRotatef(-45, 1, 0, 0);
  1957.  
  1958.         qobj = gluNewQuadric();
  1959.         gluDisk( qobj, 0.,   0.35, 32, 1);
  1960.         gluDeleteQuadric(qobj);
  1961.  
  1962.     glPopMatrix();
  1963.  
  1964.     if (backNow)
  1965.         glEnable(GL_CULL_FACE);
  1966.     else
  1967.         glDisable(GL_CULL_FACE);
  1968.  
  1969.     glPushMatrix();     
  1970.  
  1971.         glTranslatef(0,  .4,   0);
  1972.         glRotatef(-45, 1, 0, 0);
  1973.  
  1974.         glColor3fv(colorgrey1);
  1975.  
  1976.         glBegin(GL_LINE_STRIP);
  1977.             glVertex3fv(sat0);
  1978.             glVertex3fv(sat1);
  1979.             glVertex3fv(sat2);  
  1980.         glEnd();
  1981.  
  1982.         glBegin(GL_LINE_STRIP);
  1983.             glVertex3fv(sat3);
  1984.             glVertex3fv(sat1);
  1985.             glVertex3fv(sat4);  
  1986.         glEnd();
  1987.     glPopMatrix();
  1988.     
  1989.     glLineWidth(lineWidthNow);
  1990.     }
  1991.  
  1992. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1993. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1994. /* draw drive in theatre screen                                  */
  1995. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  1996.   
  1997. void drawBuilding26(int rorl, int detail)
  1998.     {
  1999.     /***************************/
  2000.     /* theatre screen supports */
  2001.     /***************************/
  2002.  
  2003.     float screen0[3] = {-0.39, 0.01, -0.28};
  2004.     float screen1[3] = {-0.39, 0.01,  0.28};
  2005.     float screen2[3] = { 0.39, 0.01,  0.28};
  2006.     float screen3[3] = { 0.39, 0.01, -0.28};
  2007.     float screen4[3] = {-0.39, 0.79,  0.28};
  2008.     float screen5[3] = { 0.39, 0.79,  0.28};
  2009.     float screen6[3] = { 0.39, 0.01, -0.28};
  2010.  
  2011.  
  2012.     static float vec1[3]={0,1,0};
  2013.     static float vec2[3]={1,1,0};
  2014.     static float vec3[3]={1,0,0};
  2015.     static float vec4[3]={0,0,0};
  2016.     
  2017.     static float tv1[2] = {0,1};
  2018.     static float tv2[2] = {1,1};
  2019.     static float tv3[2] = {1,0};
  2020.     static float tv4[2] = {0,0};
  2021.  
  2022.     GLfloat lineWidthNow;
  2023.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  2024.  
  2025.     /* supports for the screen */
  2026.     
  2027.     glColor4fv(colorgrey2);
  2028.     /* if line widths are integral Mesa chokes in a large window */
  2029.     glLineWidth(3.01);
  2030.     
  2031.     glBegin(GL_LINE_LOOP);
  2032.         glVertex3fv(screen0);
  2033.         glVertex3fv(screen1);
  2034.         glVertex3fv(screen2);
  2035.         glVertex3fv(screen3);
  2036.     glEnd();
  2037.  
  2038.     glBegin(GL_LINE_LOOP);
  2039.         glVertex3fv(screen0);
  2040.         glVertex3fv(screen4);
  2041.         glVertex3fv(screen5);
  2042.         glVertex3fv(screen6);
  2043.     glEnd();
  2044.  
  2045.  
  2046.     /* back of the screen */    
  2047.     makercubenobtm( 0, 0.42, 0.28, 0.4,0.42, 0.01, colorwhite);
  2048.  
  2049.     if ((detail >= 2) &&  (picleft != NULL) && (picright != NULL))
  2050.         {       
  2051.         glPushMatrix();
  2052.             glColor4fv(colorwhite);
  2053.  
  2054.         
  2055.             if (rorl == 0)
  2056.                 glCallList(leftScreen);
  2057.             else
  2058.                 glCallList(rightScreen);
  2059.                 
  2060.             glEnable(GL_TEXTURE_2D);
  2061.         
  2062.         
  2063.             glTranslatef(0.4, 0, 0.3);
  2064.             glScalef(0.8, 0.8,  0.01);
  2065.         
  2066.             glRotatef(180, 0, 1, 0);
  2067.         
  2068.             glBegin(GL_QUADS);
  2069.  
  2070.                 glTexCoord2fv(tv1);
  2071.                 glVertex3fv(vec1);
  2072.                 
  2073.                 glTexCoord2fv(tv2);
  2074.                 glVertex3fv(vec2);
  2075.                 
  2076.                 glTexCoord2fv(tv3);
  2077.                 glVertex3fv(vec3);
  2078.                 
  2079.                 glTexCoord2fv(tv4);
  2080.                 glVertex3fv(vec4);
  2081.             
  2082.             glEnd();
  2083.         
  2084.             glDisable(GL_TEXTURE_2D);
  2085.  
  2086.  
  2087.         glPopMatrix();
  2088.         }  
  2089.        
  2090.     glLineWidth(lineWidthNow);
  2091. }
  2092.  
  2093.  
  2094. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2095. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2096. /* draw fountain                                                 */
  2097. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2098.  
  2099. void drawBuilding29(int itsChristmas, int detail)
  2100.     {
  2101.     makercubenobtm(  0,  .05, 0,  .3, .05, .3, colorwhite);
  2102.  
  2103.     makercubenobtm(  .25,  .1, 0,  .05, .1, .3, colorwhite);
  2104.     makercubenobtm(  -.25,  .1, 0,  .05, .1, .3, colorwhite);
  2105.     makercubenobtm(  0,  .1, .25,  .3, .1, .05, colorwhite);
  2106.     makercubenobtm(  0,  .1, -.25,  .3, .1, .05, colorwhite);
  2107.  
  2108.     makeitPyr(3, colorgrey1,  0,  0.3, 0,  0.1, 0.3, 0.1);
  2109.     
  2110.     if (!itsChristmas)
  2111.         {
  2112.         if (detail > 0) 
  2113.             glEnable(GL_BLEND);
  2114.         makercubenobtm(  0,  .1, 0,  .19, .11, .19, colormaserblue);
  2115.         glDisable(GL_BLEND);
  2116.         }
  2117.     }
  2118.  
  2119.    
  2120. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2121. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2122. /* draw hero beam in effect                                      */
  2123. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2124.  
  2125. void drawBuilding33(int count, int detail)
  2126.     {
  2127.     float c[4], height;
  2128.    
  2129.     c[0] = colorred[0];
  2130.     c[1] = colorred[1] + (count/40.0);
  2131.     c[2] = colorred[2];
  2132.     c[3] = 1 - (count/20.0);
  2133.  
  2134.     height = .8 - 0.04*count;
  2135.    
  2136.     if (detail > 0)     
  2137.         glEnable(GL_BLEND);
  2138.     
  2139.     glPushMatrix();
  2140.         glTranslatef(-.2,  height,  -.2);
  2141.         glScalef(.2,  height,  .2);
  2142.         drawClosedCylinder(c,  c,  0, detail);
  2143.     glPopMatrix();
  2144.     
  2145.     glDisable(GL_BLEND);
  2146.     }
  2147.  
  2148. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2149. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2150. /* draw power line tower                                         */
  2151. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2152.  
  2153. void drawTower(int death, int death2)
  2154.     {
  2155.     float v1[3], v2[3], v3[3], v4[3];
  2156.     float v5[3], v6[3], v7[3], v8[3];
  2157.     float va[3], vb[3], vc[3], vd[3];
  2158.     float ve[3], vf[3], vg[3];
  2159.     float vh[3], vi[3], vj[3];
  2160.  
  2161.     float amt,  amt2;
  2162.     float samt2,  samt,  camt2;
  2163.     float melt1, melt2;
  2164.  
  2165.     
  2166.     amt = 2 * death * DEG_TO_RAD;
  2167.     amt2 = death2 * DEG_TO_RAD;
  2168.        
  2169.     samt2   = sin(amt2);
  2170.     samt    = sin(amt);
  2171.     camt2   = cos(amt);
  2172.        
  2173.     melt1 = samt2 * 0.5*samt;
  2174.     melt2 = camt2 * 0.5*samt;
  2175.     
  2176.     if (death > 0)
  2177.         glColor3fv(colorwhite);
  2178.     else
  2179.         glColor3fv(colorgrey1);
  2180.     
  2181.     if (death == 0)
  2182.         v1[1] = v2[1] = v3[1] = v4[1] = 0.7;
  2183.     else
  2184.         v1[1] = v2[1] = v3[1] = v4[1] = 0.3 + 0.4 * camt2;
  2185.  
  2186.     v1[0] = v4[0] =  -0.06;   
  2187.     v1[2] = v2[2] =   0.06;  
  2188.     v2[0] = v3[0] =   0.06;
  2189.     v3[2] = v4[2] = - 0.06;
  2190.  
  2191.     v5[0] = v8[0] =  -0.3;
  2192.     v5[1] = v6[1] = v7[1] = v8[1] = 0.0;
  2193.     v5[2] = v6[2] =   0.3;    
  2194.     v6[0] = v7[0] =   0.3;
  2195.     v7[2] = v8[2] = - 0.3;
  2196.     
  2197.     if (death == 0)
  2198.         {
  2199.         va[1] = vb[1] = vc[1] = vd[1] = 1.5;
  2200.         va[0] = v1[0];
  2201.         va[2] = v1[2];
  2202.  
  2203.         vb[0] = v2[0];
  2204.         vb[2] = v2[2];
  2205.  
  2206.         vc[0] = v3[0];
  2207.         vc[2] = v3[2];
  2208.  
  2209.         vd[0] = v4[0];
  2210.         vd[2] = v4[2];
  2211.         }
  2212.     else
  2213.         {
  2214.         va[1] = vb[1] = vc[1] = vd[1] = 1.5 * camt2;
  2215.         va[0] = v1[0]+ melt1;
  2216.         va[2] = v1[2]+ melt2;
  2217.  
  2218.         vb[0] = v2[0]+ melt1;
  2219.         vb[2] = v2[2]+ melt2;
  2220.  
  2221.         vc[0] = v3[0]+ melt1;
  2222.         vc[2] = v3[2]+ melt2;
  2223.  
  2224.         vd[0] = v4[0]+ melt1;
  2225.         vd[2] = v4[2]+ melt2;
  2226.         }
  2227.   
  2228.  
  2229.     ve[1] = vf[1] = vc[1] - 0.2;
  2230.     ve[0] = vc[0];
  2231.     ve[2] = vc[2];
  2232.  
  2233.     vf[0] = vd[0];
  2234.     vf[2] = vd[2];
  2235.   
  2236.     vg[0] = (vc[0] + vd[0]) * 0.5;
  2237.     vg[1] = vc[1] - 0.1;
  2238.     vg[2] = vc[2] - .2;
  2239.  
  2240.  
  2241.     vh[0] = va[0];
  2242.     vh[1] = vi[1] = va[1] - 0.2;
  2243.     vh[2] = va[2];
  2244.  
  2245.     vi[0] = vb[0];
  2246.     vi[2] = vb[2];
  2247.   
  2248.     vj[0] = (va[0] + vb[0]) * 0.5;
  2249.     vj[1] = va[1] - 0.1;
  2250.     vj[2] = va[2] + .2;
  2251.  
  2252.  
  2253.     /* if line widths are integral Mesa chokes in a large window */
  2254.     glLineWidth(3.01);
  2255.  
  2256.     /********/
  2257.     /* legs */
  2258.     /********/
  2259.    
  2260.     glBegin(GL_LINE_LOOP);
  2261.         glVertex3fv(v1); glVertex3fv(v2); glVertex3fv(v3); glVertex3fv(v4);
  2262.     glEnd();
  2263.     
  2264.     glBegin(GL_LINE_LOOP);
  2265.         glVertex3fv(v4); glVertex3fv(v5); glVertex3fv(v2); glVertex3fv(v7);
  2266.     glEnd();
  2267.  
  2268.     glBegin(GL_LINE_LOOP);
  2269.         glVertex3fv(v1); glVertex3fv(v6); glVertex3fv(v3); glVertex3fv(v8);
  2270.     glEnd();
  2271.  
  2272.  
  2273.     /* if line widths are integral Mesa chokes in a large window */
  2274.     glLineWidth(2.01);
  2275.  
  2276.     /*******/
  2277.     /* top */
  2278.     /*******/
  2279.  
  2280.     glBegin(GL_LINE_LOOP);
  2281.         glVertex3fv(va); glVertex3fv(vb); glVertex3fv(vc); glVertex3fv(vd);
  2282.     glEnd();
  2283.  
  2284.     /*************************/
  2285.     /* supports and verticals*/
  2286.     /*************************/
  2287.  
  2288.     glBegin(GL_LINE_STRIP);
  2289.         glVertex3fv(v7); glVertex3fv(v3); glVertex3fv(vc); glVertex3fv(vg); glVertex3fv(ve);
  2290.     glEnd();
  2291.  
  2292.     glBegin(GL_LINE_STRIP);
  2293.         glVertex3fv(v8); glVertex3fv(v4); glVertex3fv(vd); glVertex3fv(vg); glVertex3fv(vf);
  2294.     glEnd();
  2295.  
  2296.     glBegin(GL_LINE_STRIP);
  2297.         glVertex3fv(v5); glVertex3fv(v1); glVertex3fv(va); glVertex3fv(vj); glVertex3fv(vh);
  2298.     glEnd();
  2299.  
  2300.     glBegin(GL_LINE_STRIP);
  2301.         glVertex3fv(v6); glVertex3fv(v2); glVertex3fv(vb); glVertex3fv(vj); glVertex3fv(vi);
  2302.     glEnd();
  2303.  
  2304.  
  2305.     glBegin(GL_LINE_LOOP);
  2306.         glVertex3fv(ve); glVertex3fv(vf); glVertex3fv(vh); glVertex3fv(vi);
  2307.     glEnd();    
  2308.  
  2309.     }
  2310.  
  2311.  
  2312.  
  2313. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2314. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2315. /* draw the square playing field                                 */
  2316. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2317.  
  2318. void drawBattlefield(struct road * roads,  float xshift,  float zshift, 
  2319.                     int detail, int itsChristmas, int view)
  2320.     {
  2321.     float theta, radius;
  2322.     float angle;
  2323.  
  2324.     /******************************/
  2325.     /* 'where is the town' arrow  */
  2326.     /******************************/
  2327.  
  2328.     static float arrow[4][3] =          {-0.2, PLANEY + 0.01, -1.0, 
  2329.                                          -0.2, PLANEY + 0.01,  1.0, 
  2330.                                           0.2, PLANEY + 0.01,  1.0, 
  2331.                                           0.2, PLANEY + 0.01, -1.0};
  2332.                         
  2333.     static float arrowhead[3][3] =      {0.0, PLANEY + 0.01, -1.75, 
  2334.                                         -0.5, PLANEY + 0.01, -1.0,
  2335.                                          0.5, PLANEY + 0.01, -1.0};
  2336.          
  2337.     if (itsChristmas)
  2338.         glColor3fv(colorsnow);
  2339.     else
  2340.         glColor3fv(planeGreen);
  2341.  
  2342.  
  2343.     if (view == MAPVIEW)
  2344.         glCallList(bigPlane);    
  2345.     else if (detail <= 1)
  2346.         glCallList(lowDPlane);    
  2347.     else
  2348.         glCallList(highDPlane);
  2349.  
  2350.  
  2351.     /***************/
  2352.     /* draw roads  */
  2353.     /***************/
  2354.  
  2355.     drawRoads(roads, xshift, zshift, itsChristmas, view, detail);
  2356.     
  2357.     
  2358.     radius = sqrt(xshift * xshift + zshift * zshift);
  2359.     
  2360.     if (radius > 36)
  2361.         {
  2362.         /**********************/
  2363.         /* draw town pointer  */
  2364.         /**********************/
  2365.         
  2366.         if (zshift == 0)
  2367.             zshift = NEARZERO; 
  2368.                 
  2369.         theta = atan(xshift / zshift);
  2370.  
  2371.         if (zshift > 0)
  2372.             theta += PI;
  2373.  
  2374.         angle =  theta * RAD_TO_SMALL_DEG;
  2375.  
  2376.     
  2377.         glPushMatrix();
  2378.             glRotatef(angle, 0, 1, 0);
  2379.     
  2380.             glColor3fv(colorred);
  2381.  
  2382.             glBegin(GL_QUADS);
  2383.                 glVertex3fv(arrow[0]);
  2384.                 glVertex3fv(arrow[1]);
  2385.                 glVertex3fv(arrow[2]);
  2386.                 glVertex3fv(arrow[3]);
  2387.             glEnd();
  2388.  
  2389.             glBegin(GL_TRIANGLES);
  2390.                 glVertex3fv(arrowhead[0]);
  2391.                 glVertex3fv(arrowhead[1]);
  2392.                 glVertex3fv(arrowhead[2]);
  2393.             glEnd();
  2394.         glPopMatrix();
  2395.         
  2396.  
  2397.         }
  2398.     }
  2399.  
  2400. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2401. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2402. /* draw square lake segment                                      */
  2403. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2404.  
  2405. void drawLake0(int itsChristmas)
  2406.     {   
  2407. static    float lake[4][3] =    {-0.3,  0.0, -0.3, 
  2408.                                   0.3,  0.0, -0.3, 
  2409.                                   0.3,  0.0,  0.3, 
  2410.                                  -0.3,  0.0,  0.3};
  2411.  
  2412.     if (itsChristmas)
  2413.         glColor3fv(colorblue);
  2414.     else
  2415.         glColor3fv(colorwater);
  2416.         
  2417.     glBegin(GL_QUADS);
  2418.         glVertex3fv(lake[3]);
  2419.         glVertex3fv(lake[2]);
  2420.         glVertex3fv(lake[1]);
  2421.         glVertex3fv(lake[0]);
  2422.     glEnd();
  2423.     }
  2424.  
  2425. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2426. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2427. /* draw triangular lake segment                                  */
  2428. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2429.  
  2430. void drawLake1(int itsChristmas)
  2431.     {    
  2432.     float lake2[3][3] =         {-0.3,  0.0, -0.3, 
  2433.                                   0.3,  0.0, -0.3, 
  2434.                                  -0.3,  0.0,  0.3};
  2435.  
  2436.     if (itsChristmas)
  2437.         glColor3fv(colorblue);
  2438.     else
  2439.         glColor3fv(colorwater);
  2440.     
  2441.     glBegin(GL_TRIANGLES);
  2442.         glVertex3fv(lake2[2]);
  2443.         glVertex3fv(lake2[1]);
  2444.         glVertex3fv(lake2[0]);
  2445.     glEnd();
  2446.     }
  2447.  
  2448. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2449. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2450. /* draw central hill segment                                     */
  2451. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2452.  
  2453. void drawHill0(int itsChristmas)
  2454.     {   
  2455. static     float hill[4][3] =   {-0.3, 0.6, -0.3, 
  2456.                                   0.3, 0.6, -0.3, 
  2457.                                   0.3, 0.6,  0.3, 
  2458.                                  -0.3, 0.6,  0.3};
  2459.  
  2460.  
  2461.     if (itsChristmas)
  2462.         glColor3fv(colorsnow);
  2463.     else
  2464.         glColor3fv(planeGreen2);
  2465.         
  2466.     glBegin(GL_QUADS);
  2467.         glVertex3fv(hill[3]);
  2468.         glVertex3fv(hill[2]);
  2469.         glVertex3fv(hill[1]);
  2470.         glVertex3fv(hill[0]);
  2471.     glEnd();
  2472.     
  2473.     }
  2474.  
  2475. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2476. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2477. /* draw side of hill                                             */
  2478. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2479.  
  2480. void drawHill1(int sidemod, int itsChristmas)
  2481.     {   
  2482.     float c[4];
  2483.  
  2484. static    float side[4][3] =    {-0.3, 0.6, -0.3, 
  2485.                                   0.3, 0.6, -0.3, 
  2486.                                   0.3, 0.0,  0.3, 
  2487.                                  -0.3, 0.0,  0.3};
  2488.     
  2489.     if (itsChristmas)
  2490.         {
  2491.         c[0] =  colorsnow2[0];   
  2492.         c[1] =  colorsnow2[1];   
  2493.         c[2] =  colorsnow2[2];   
  2494.         }
  2495.     else
  2496.         {
  2497.         c[0] =  planeGreen3[0];   
  2498.         c[1] =  planeGreen3[1];   
  2499.         c[2] =  planeGreen3[2];  
  2500.         } 
  2501.         
  2502.     c[0] -= sidemod*0.04;
  2503.     c[1] -= sidemod*0.04;
  2504.     c[2] -= sidemod*0.04;
  2505.  
  2506.     if (c[0] < 0)
  2507.         c[0] = 0;
  2508.     if (c[1] < 0)
  2509.         c[1] = 0;
  2510.     if (c[2] < 0)
  2511.         c[2] = 0;
  2512.             
  2513.     glColor3fv(c);
  2514.     
  2515.     glBegin(GL_QUADS);
  2516.         glVertex3fv(side[3]);
  2517.         glVertex3fv(side[2]);
  2518.         glVertex3fv(side[1]);
  2519.         glVertex3fv(side[0]);
  2520.     glEnd();
  2521.  
  2522.     }
  2523.  
  2524. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2525. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2526. /* draw corner of hill                                           */
  2527. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2528.  
  2529. void drawHill2(int sidemod, int itsChristmas)
  2530.     {   
  2531.     float c[4];
  2532.  
  2533. static    float corner[3][3] =  {-0.3, 0.6, -0.3, 
  2534.                                   0.3, 0.0, -0.3, 
  2535.                                  -0.3, 0.0,  0.3};
  2536.  
  2537.     if (itsChristmas)
  2538.         {
  2539.         c[0] =  colorsnow2[0];   
  2540.         c[1] =  colorsnow2[1];   
  2541.         c[2] =  colorsnow2[2];   
  2542.         }
  2543.     else
  2544.         {
  2545.         c[0] =  planeGreen3[0];   
  2546.         c[1] =  planeGreen3[1];   
  2547.         c[2] =  planeGreen3[2];  
  2548.         } 
  2549.  
  2550.     c[0] -= (sidemod*0.04 + 0.02);
  2551.     c[1] -= (sidemod*0.04 + 0.02);
  2552.     c[2] -= (sidemod*0.04 + 0.02);
  2553.  
  2554.     if (c[0] < 0)
  2555.         c[0] = 0;
  2556.     if (c[1] < 0)
  2557.         c[1] = 0;
  2558.     if (c[2] < 0)
  2559.         c[2] = 0;
  2560.  
  2561.     glColor3fv(c);
  2562.    
  2563.     glBegin(GL_TRIANGLES);
  2564.         glVertex3fv(corner[2]);
  2565.         glVertex3fv(corner[1]);
  2566.         glVertex3fv(corner[0]);
  2567.     glEnd();
  2568.  
  2569.     }
  2570.     
  2571. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2572. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2573. /* draw inside corner of hill                                    */
  2574. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2575.  
  2576. void drawHill3(int sidemod, int itsChristmas)
  2577.     {
  2578.    float c[4];
  2579.  
  2580. static    float insidecorner[4][3] =    {-0.3, 0.6, -0.3, 
  2581.                                   0.3, 0.6, -0.3, 
  2582.                                  -0.3, 0.6,  0.3, 
  2583.                                   0.3, 0.0,  0.3 };
  2584.  
  2585.     if (itsChristmas)
  2586.         glColor3fv(colorsnow);
  2587.     else
  2588.         glColor3fv(planeGreen2);
  2589.  
  2590.     glBegin(GL_TRIANGLES);
  2591.         glVertex3fv(insidecorner[2]);
  2592.         glVertex3fv(insidecorner[1]);
  2593.         glVertex3fv(insidecorner[0]);
  2594.     glEnd();
  2595.  
  2596.     if (itsChristmas)
  2597.         {
  2598.         c[0] =  colorsnow2[0];   
  2599.         c[1] =  colorsnow2[1];   
  2600.         c[2] =  colorsnow2[2];   
  2601.         }
  2602.     else
  2603.         {
  2604.         c[0] =  planeGreen3[0];   
  2605.         c[1] =  planeGreen3[1];   
  2606.         c[2] =  planeGreen3[2];  
  2607.         } 
  2608.  
  2609.     c[0] -= (sidemod*0.04 + 0.02);
  2610.     c[1] -= (sidemod*0.04 + 0.02);
  2611.     c[2] -= (sidemod*0.04 + 0.02);
  2612.  
  2613.     if (c[0] < 0)
  2614.         c[0] = 0;
  2615.     if (c[1] < 0)
  2616.         c[1] = 0;
  2617.     if (c[2] < 0)
  2618.         c[2] = 0;
  2619.  
  2620.     glColor3fv(c);
  2621.  
  2622.     glBegin(GL_TRIANGLES);
  2623.         glVertex3fv(insidecorner[2]);
  2624.         glVertex3fv(insidecorner[3]);
  2625.         glVertex3fv(insidecorner[1]);
  2626.     glEnd();
  2627.     }
  2628.  
  2629. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2630.  
  2631.  void drawWater(int shape,  int itsChristmas)
  2632.     {
  2633.     switch(shape){
  2634.         case 0:     drawLake0(itsChristmas);
  2635.                     break;
  2636.                     
  2637.         case 1:     drawLake1(itsChristmas);    /*   |/ */
  2638.                     break;
  2639.                     
  2640.         case 2:     glRotatef(-90, 0, 1, 0);    /* \| */
  2641.                     drawLake1(itsChristmas);
  2642.                     break;
  2643.                     
  2644.         case 3:     glRotatef(-180, 0, 1, 0);   /* /| */
  2645.                     drawLake1(itsChristmas);
  2646.                     break;
  2647.                     
  2648.         case 4:     glRotatef(90, 0, 1, 0);     /* |\ */
  2649.                     drawLake1(itsChristmas);
  2650.                     break;
  2651.         }
  2652.     }
  2653.  
  2654. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2655.  
  2656.  void drawHills(int shape,  int itsChristmas)
  2657.     {
  2658.     switch(shape){
  2659.         case 0:     drawHill0(itsChristmas);
  2660.                     break;
  2661.                     
  2662.         case 1:     drawHill1(0, itsChristmas); /* up neg Z */
  2663.                     break;
  2664.                     
  2665.         case 2:     glRotatef(-90, 0, 1, 0);    /* up pos x */
  2666.                     drawHill1(1, itsChristmas);
  2667.                     break;
  2668.                     
  2669.         case 3:     glRotatef(-180, 0, 1, 0);   /* up pos z */
  2670.                     drawHill1(2, itsChristmas);
  2671.                     break;
  2672.                     
  2673.         case 4:     glRotatef(90, 0, 1, 0);     /* up neg x */
  2674.                     drawHill1(1, itsChristmas);
  2675.                     break;
  2676.                     
  2677.                     
  2678.         case 5:     drawHill2(0,  itsChristmas); /* +x,+z corner */
  2679.                     break;
  2680.                     
  2681.         case 6:     glRotatef(-90, 0, 1, 0);    /* up pos x */
  2682.                     drawHill2(0, itsChristmas);
  2683.                     break;
  2684.                     
  2685.         case 7:     glRotatef(-180, 0, 1, 0);   /* up pos z */
  2686.                     drawHill2(1, itsChristmas);
  2687.                     break;
  2688.                     
  2689.         case 8:     glRotatef(90, 0, 1, 0);     /* up neg x */
  2690.                     drawHill2(1, itsChristmas);
  2691.                     break;
  2692.                     
  2693.                     
  2694.         case 9:     drawHill3(0, itsChristmas); /* up +x,-z */
  2695.                     break;
  2696.                     
  2697.         case 10:    glRotatef(-90, 0, 1, 0);    /* up +x,+z */
  2698.                     drawHill3(0, itsChristmas);
  2699.                     break;
  2700.                     
  2701.         case 11:    glRotatef(-180, 0, 1, 0);   /* up pos z */
  2702.                     drawHill3(1, itsChristmas);
  2703.                     break;
  2704.                     
  2705.         case 12:    glRotatef(90, 0, 1, 0);     /* up neg x */
  2706.                     drawHill3(1, itsChristmas);
  2707.                     break;
  2708.  
  2709.         }
  2710.     }
  2711.  
  2712.  
  2713. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2714. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2715. /* draw all structures on plane (buildings,trees,hills,lakes)    */
  2716. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  2717.  
  2718. void drawtrees(struct tree * allTreesOnPlane, int numTreesOnPlane, int counter, 
  2719.                 int detail, int itsChristmas, int view)
  2720.     {
  2721.     
  2722.     float spheredat[4];
  2723.     float x, y, z;
  2724.     register int treeCounter;
  2725.     int sph;
  2726.     GLfloat lineWidthNow;
  2727.     GLint shadeNow;
  2728.     
  2729.     glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
  2730.   
  2731.     if (detail >= 2)
  2732.         sph = 5;
  2733.     else if (detail == 1)
  2734.         sph = 4;
  2735.     else
  2736.         sph = 2;
  2737.  
  2738.  
  2739.     for (treeCounter=0; treeCounter < numTreesOnPlane; treeCounter++)
  2740.         {
  2741.         if (detail >= 2)
  2742.             glShadeModel(GL_SMOOTH);
  2743.         else
  2744.             glShadeModel(GL_FLAT);
  2745.  
  2746.  
  2747.         if (((fabs(allTreesOnPlane[treeCounter].x) <= PLANESIZE) && (fabs(allTreesOnPlane[treeCounter].z) <= PLANESIZE)) || (view == MAPVIEW))
  2748.             {
  2749.             x = allTreesOnPlane[treeCounter].x;
  2750.             y = allTreesOnPlane[treeCounter].y;
  2751.             z = allTreesOnPlane[treeCounter].z;
  2752.  
  2753.             /**********************************/
  2754.             /* tree                           */
  2755.             /**********************************/
  2756.  
  2757.             if (allTreesOnPlane[treeCounter].type == 0)
  2758.                 {           
  2759.                 if ((allTreesOnPlane[treeCounter].treeshape == 0) || (itsChristmas))
  2760.                     {
  2761.                     /*************/
  2762.                     /* pine tree */
  2763.                     /*************/
  2764.                     
  2765.                     if (detail >= 2)
  2766.                         {
  2767.                         glCallList(treeWood);
  2768.  
  2769.                         glEnable(GL_TEXTURE_2D);
  2770.                         }
  2771.  
  2772.  
  2773.                     makercubenobtmnotopTEX( x, y+0.2, z, 0.075, 0.2, 0.075, colorbrown);
  2774.                     glDisable(GL_TEXTURE_2D);
  2775.     
  2776.                     /* regular pine tree colour is too dark in vector mode */
  2777.     
  2778.                     if (detail > -1)
  2779.                         makeitPyr(1, treeColor, x, y+0.8, z, 0.2, 0.4, 0.2);
  2780.                     else
  2781.                         makeitPyr(1, treeColor2, x, y+0.8, z, 0.2, 0.4, 0.2);
  2782.     
  2783.                     glColor4fv(colorblack);
  2784.  
  2785.                     if (detail > 0)                 
  2786.                         drawShadow(x, z, 0.2, 0.2);
  2787.                     
  2788.                     if (itsChristmas)
  2789.                         {
  2790.                         makercube( x+0.09, y+0.9, z+0.09, 0.025, 0.025, 0.025, coloryellow);
  2791.                         makercube( x-0.12, y+0.7, z+0.12, 0.025, 0.025, 0.025, colorred);
  2792.                         makercube( x-0.1,  y+0.9, z-0.1,  0.025, 0.025, 0.025, colormaserblue);
  2793.                         makercube( x+0.12, y+0.7, z-0.12, 0.025, 0.025, 0.025, colororange);
  2794.                         }
  2795.                     }
  2796.                 else
  2797.                     /**************/
  2798.                     /* round tree */
  2799.                     /**************/
  2800.                     {
  2801.                     if (detail >= 2)
  2802.                         {
  2803.                         glCallList(treeWood);
  2804.  
  2805.                         glEnable(GL_TEXTURE_2D);
  2806.                         }
  2807.  
  2808.                     makercubenobtmnotopTEX(x, y+0.4, z, 0.1, 0.4, 0.1, colorbrown);
  2809.                     glDisable(GL_TEXTURE_2D);
  2810.     
  2811.                     glColor3fv(treeColor2);
  2812.                     spheredat[0] = x;
  2813.                     spheredat[1] = y+1;
  2814.                     spheredat[2] = z;
  2815.                     spheredat[3] = 0.3;
  2816.                     andysphdraw(spheredat, sph);
  2817.  
  2818.                     if (detail > 0)     
  2819.                         {
  2820.                         glPushMatrix();
  2821.                             glColor3fv(colorblack);
  2822.                             glTranslatef(x,  SHADOWS,   z);
  2823.                             glCallList(roundTreeShadow);
  2824.                         glPopMatrix();
  2825.                         }
  2826.                     }
  2827.                 }
  2828.  
  2829.             /**********************************/
  2830.             /* building                       */
  2831.             /**********************************/
  2832.                     
  2833.             if (allTreesOnPlane[treeCounter].type == 1)
  2834.                 {
  2835.                 glPushMatrix();
  2836.  
  2837.                     glTranslatef(x,  y,  z);
  2838.                     
  2839.                     if (allTreesOnPlane[treeCounter].treeshape <= 17)
  2840.                         switch(allTreesOnPlane[treeCounter].treeshape){
  2841.                             case 0:     drawBuilding0(colorwhite, detail);
  2842.                                         break;
  2843.                             case 1:     if (detail == 0)
  2844.                                             glCallList(building1ObjD0);
  2845.                                         else
  2846.                                             glCallList(building1Obj);
  2847.                                         break;
  2848.                             case 2:     if (detail == 0)
  2849.                                             glCallList(building2ObjD0);
  2850.                                         else
  2851.                                             glCallList(building2Obj);
  2852.                                         break;
  2853.                             case 3:     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  2854.                                         if (allTreesOnPlane[treeCounter].deathCount && allTreesOnPlane[treeCounter].death2)
  2855.                                             drawTower(allTreesOnPlane[treeCounter].deathCount, allTreesOnPlane[treeCounter].death2);
  2856.                                         else
  2857.                                             glCallList(powerTower);
  2858.                                         glLineWidth(lineWidthNow);
  2859.                                         break;
  2860.                             case 4:     glPushAttrib(GL_LIGHTING_BIT);
  2861.                                         if (detail <= 0)
  2862.                                             {
  2863.                                             glShadeModel(GL_FLAT);
  2864.                                             drawCoolingTower(detail);
  2865.                                             }
  2866.                                         else
  2867.                                             {
  2868.                                             glShadeModel(GL_SMOOTH);
  2869.                                             drawCoolingTower(detail);    /* cooling tower */
  2870.                                             }
  2871.                                         glPopAttrib();
  2872.                                         break;
  2873.                             case 5:     if (detail == 0)         /* home */
  2874.                                             glCallList(building5ObjD0);
  2875.                                         else
  2876.                                             glCallList(building5Obj);
  2877.                                         break;
  2878.                             case 6:     drawBuilding6(counter, colorred, coloryellow, detail); /* fast food */
  2879.                                         break;
  2880.                             case 7:     glCallList(building7Obj);
  2881.                                         break;
  2882.                             case 8:     drawBuilding8(colorbeige,  colorbrown, detail);
  2883.                                         break;
  2884.                             case 9:     glPushAttrib(GL_LIGHTING_BIT);
  2885.                                         if (detail < 0)
  2886.                                             {
  2887.                                             glShadeModel(GL_FLAT);
  2888.                                             glCallList(building9ObjOO);
  2889.                                             }
  2890.                                         else if (detail == 0)
  2891.                                             {
  2892.                                             glShadeModel(GL_FLAT);
  2893.                                             glCallList(building9Obj);
  2894.                                             }
  2895.                                         else
  2896.                                             {
  2897.                                             glShadeModel(GL_SMOOTH);
  2898.                                             glCallList(building9Obj);       /*water tower*/
  2899.                                             }
  2900.                                         glPopAttrib();
  2901.                                         break;
  2902.                             case 10:    glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  2903.                                         glCallList(building10Obj);
  2904.                                         glLineWidth(lineWidthNow);
  2905.                                         break;
  2906.                             case 11:    glPushAttrib(GL_LIGHTING_BIT);
  2907.                                         if (detail <= 0)
  2908.                                             glShadeModel(GL_FLAT);
  2909.                                         else
  2910.                                             glShadeModel(GL_SMOOTH);
  2911.                                         drawBuilding11(detail);             /* factory smokestacks*/
  2912.                                         glPopAttrib();
  2913.                                         break;
  2914.                             case 12:    if (detail == 0)
  2915.                                             glCallList(building12ObjD0);
  2916.                                         else
  2917.                                             glCallList(building12Obj);
  2918.                                         break;
  2919.                             case 13:    glRotatef(180, 0, 1, 0);
  2920.                                         if (detail == 0)
  2921.                                             glCallList(building5ObjD0);
  2922.                                         else
  2923.                                             glCallList(building5Obj);
  2924.                                         break;
  2925.                             case 14:    glCallList(building14Obj);
  2926.                                         break;
  2927.                             case 15:    glCallList(strip1Obj);  /* strip mall */
  2928.                                         break;
  2929.                             case 16:    glCallList(strip2Obj);  /* strip mall */
  2930.                                         break;
  2931.                             case 17:    glCallList(strip3Obj);  /* strip mall */
  2932.                                         break;
  2933.                             }
  2934.                     else
  2935.                         switch(allTreesOnPlane[treeCounter].treeshape){
  2936.                             case 18:    glRotatef(90, 0, 1, 0);
  2937.                                         drawBuilding0(colorgrey1, detail);
  2938.                                         break;
  2939.                             case 19:    if (detail == 0)
  2940.                                             glCallList(building19ObjD0);
  2941.                                         else
  2942.                                             glCallList(building19Obj);
  2943.                                         break;
  2944.                             case 20:    if (detail == 0)
  2945.                                             glCallList(building20ObjD0);
  2946.                                         else
  2947.                                             glCallList(building20Obj);
  2948.                                         break;
  2949.                             case 21:    if (detail == 0)
  2950.                                             glCallList(building21ObjD0);
  2951.                                         else
  2952.                                             glCallList(building21Obj);
  2953.                                         break;
  2954.                             case 22:    drawBuilding22(colorgrey1);
  2955.                                         break;
  2956.                             case 23:    drawBuilding22(colorgrey2);
  2957.                                         break;
  2958.                             case 24:    drawBuilding22(colorwhite);
  2959.                                         break;
  2960.                             case 25:    drawBuilding25();
  2961.                                         break;
  2962.                             case 26:    drawBuilding26(0, detail);
  2963.                                         break;
  2964.                             case 27:    drawBuilding26(1, detail);
  2965.                                         break;
  2966.                             case 28:    glRotatef(-90, 0, 1, 0);
  2967.                                         drawBuilding6(counter, colorgrey2, colorblue, detail);
  2968.                                         break;
  2969.                             case 29:    drawBuilding29(itsChristmas, detail);
  2970.                                         break;
  2971.                             case 30:    drawBuilding8(colorbeige,  colorgrey2, detail);
  2972.                                         break;
  2973.                             case 31:    glCallList(building31Obj); /* maser battery */
  2974.                                         break;
  2975.                             case 32:    glCallList(building32Obj); /* helo pad */
  2976.                                         break;
  2977.                             case 33:    drawBuilding33(allTreesOnPlane[treeCounter].deathCount, detail); /* hero entrance */
  2978.                                         break;
  2979.                             case 34:    drawBuilding34(colorblue2); /* smallest office building */
  2980.                                         break;
  2981.                             case 36:    drawBuilding36(colorblue2); /* small office building */
  2982.                                         break;
  2983.                             case 37:    drawBuilding37(colorblue2, detail);
  2984.                                         break;
  2985.                             default:    showError("Bogus Building in Tree List! (drawtrees)");
  2986.                                         break;
  2987.                         }
  2988.  
  2989.                 glPopMatrix();  
  2990.                 }
  2991.  
  2992.             /**********************************/
  2993.             /* water                          */
  2994.             /**********************************/
  2995.                 
  2996.             if (allTreesOnPlane[treeCounter].type == 2)
  2997.                 {
  2998.                 glPushMatrix();
  2999.                     glTranslatef(x,  ROADS,  z);
  3000.                     
  3001.                     drawWater(allTreesOnPlane[treeCounter].treeshape, itsChristmas);
  3002.                     
  3003.                 glPopMatrix();
  3004.                 }
  3005.  
  3006.             /**********************************/
  3007.             /* hills                          */
  3008.             /**********************************/
  3009.  
  3010.             if (allTreesOnPlane[treeCounter].type == 3)
  3011.                 {
  3012.                 glPushMatrix();
  3013.                     glTranslatef(x, PLANEY, z);             
  3014.                     drawHills(allTreesOnPlane[treeCounter].treeshape, itsChristmas);                
  3015.                 glPopMatrix();
  3016.                 }           
  3017.             }
  3018.         }
  3019.         glShadeModel(shadeNow);
  3020.     }
  3021.  
  3022.  
  3023. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3024. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3025. /* draw all tanks currently dying                                */
  3026. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3027.  
  3028. void drawSlagTanks(struct tank * allSlags, int counter, int detail)
  3029.     {    
  3030.     int c;
  3031.     float angle2;
  3032.     struct tank * ttank;
  3033.     
  3034.     for(ttank = allSlags->next;ttank != NULL;ttank = ttank->next)
  3035.         {
  3036.         if ((fabs(ttank->x) <= PLANESIZE) && (fabs(ttank->z) <= PLANESIZE))
  3037.             {
  3038.             angle2 = ttank->theta * RAD_TO_SMALL_DEG;
  3039.  
  3040.             c = ttank->count;
  3041.                     
  3042.             glPushMatrix();
  3043.         
  3044.             switch(ttank->type){
  3045.                 case TANK:      glTranslatef(ttank->x, ttank->y-0.015, ttank->z);
  3046.                                 glScalef(1+0.015*c,  1-0.015*c,  1+0.015*c);
  3047.                                 glRotatef(angle2, 0, 1, 0);
  3048.                                 glCallList(slagtank);
  3049.                                 break;
  3050.         
  3051.                 case LAUNCHER:  glTranslatef(ttank->x, ttank->y-0.015, ttank->z);
  3052.                                 glScalef(1+0.015*c,  1-0.015*c,  1+0.015*c);
  3053.                                 glRotatef(angle2, 0, 1, 0);
  3054.                                 glCallList(slaglaunchertank);
  3055.                                 break;
  3056.         
  3057.                             
  3058.                 case MASERTANK: glTranslatef(ttank->x, ttank->y-0.015, ttank->z);
  3059.                                 glScalef(0.15+0.002*c,  0.15-0.004*c,  0.15+0.002*c);
  3060.                                 glRotatef(angle2, 0, 1, 0);
  3061.                                 glCallList(slagmasertank);
  3062.                                 break;
  3063.   
  3064.                 case HELO:      glTranslatef(ttank->x, ttank->y, ttank->z);
  3065.                                 glRotatef(c*4.0, 1, 0, 0);
  3066.                                 glRotatef(c*1.5, 0, 0, 1);
  3067.                                 glRotatef(angle2+180+(c*10), 0, 1, 0);
  3068.                                 drawHelo((counter*9) % 360, 1);
  3069.                                 break;
  3070.  
  3071.                 case CHH:       glTranslatef(ttank->x, ttank->y, ttank->z);
  3072.                                 glRotatef(c*4.0, 1, 0, 0);
  3073.                                 glRotatef(c*1.5, 0, 0, 1);
  3074.                                 glRotatef(angle2+(c*10), 0, 1, 0);
  3075.                                 makeCHH(0);
  3076.                                 break;
  3077.  
  3078.                 case MECHAG:    glTranslatef(ttank->x, 0, ttank->z);
  3079.                                 glRotatef(angle2, 0, 1, 0);
  3080.                                 drawMechaMonster(0, counter, detail);
  3081.                                 break;
  3082.                                 
  3083.                 case HERO:      glTranslatef(ttank->x, 0, ttank->z);
  3084.                                 glRotatef(angle2, 0, 1, 0);
  3085.                                 if (ttank->subtype == 0)
  3086.                                     drawHeroDude(0, ttank->walking, ttank->maserCount, c, detail);
  3087.                                 else
  3088.                                     drawHeroDude2(0, ttank->walking, ttank->maserCount, c, detail);
  3089.                                 break;
  3090.                                 
  3091.                 case AIRPLANE:  glTranslatef(ttank->x, ttank->y, ttank->z);
  3092.                                 glRotatef(c*1.5, 0, 0, 1);
  3093.                                 glRotatef(angle2+180+(c*10), 0, 1, 0);
  3094.                                 glScalef(3,  3,  3);
  3095.                                 drawAirplane((counter*2) % 360);
  3096.                                 break;
  3097.  
  3098.                 case FIGHTER:   glTranslatef(ttank->x, ttank->y, ttank->z);
  3099.                                 glRotatef(c*1.5, 0, 0, 1);
  3100.                                 glRotatef(angle2+180+(c*10), 0, 1, 0);
  3101.                                 glScalef(2,  2,  2);
  3102.                                 drawFighter();
  3103.                                 break;
  3104.                                 
  3105.                 default:        showError("Bogus Vehicle in Tank List! (drawSlagTanks)");
  3106.                                 break;
  3107.                 }
  3108.                     
  3109.             glPopMatrix();
  3110.             }
  3111.         }
  3112.     }
  3113.  
  3114. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3115. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3116. /* draw maser beams                                              */
  3117. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3118.  
  3119. void drawMaser(float sourceX, float sourceY, float sourceZ,
  3120.                 int shooter, float mX, float mZ, float mHeight, float mBottom, 
  3121.                 float r1, float r2, float r3, int width, int view, int detail)
  3122.  
  3123.     {
  3124.     float beamLoc1[3],  beamLoc2[3];
  3125.     GLfloat lineWidthNow;
  3126.  
  3127.     beamLoc1[0] = sourceX;
  3128.     beamLoc1[1] = sourceY;
  3129.     beamLoc1[2] = sourceZ;
  3130.  
  3131.     beamLoc2[0] = mX + r1;
  3132.     beamLoc2[1] = 0.5 * (mHeight - mBottom) + mBottom + r2;
  3133.     beamLoc2[2] = mZ + r3;
  3134.  
  3135.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  3136.  
  3137.     /* if line widths are integral Mesa chokes in a large window */
  3138.     if ((view == MONSTERVIEW) || (view == ARMYVIEW))
  3139.         glLineWidth(width * 0.0057);
  3140.     else
  3141.         glLineWidth(width * 0.0029);
  3142.     
  3143.     
  3144.     glColor3fv(colorwhite);
  3145.  
  3146.     glBegin(GL_LINES);
  3147.         glVertex3fv(beamLoc1);
  3148.         glVertex3fv(beamLoc2);
  3149.  
  3150.     glEnd();
  3151.  
  3152.  
  3153.     switch(shooter)
  3154.         {
  3155.         case MASERTANK:     glColor3fv(colormaserblue);
  3156.                             break;
  3157.                             
  3158.         case CHH:           glColor3fv(colormaseryellow);
  3159.                             break;
  3160.                             
  3161.         case MECHAG:        glColor3fv(colorred);
  3162.                             break;
  3163.                             
  3164.         default:            showError("Invalid Vehicle Type (drawMaser)");
  3165.                             break;
  3166.         }
  3167.         
  3168.     if (detail != -1)
  3169.         glEnable(GL_BLEND);
  3170.     
  3171.     /* if line widths are integral Mesa chokes in a large window */
  3172.     if ((view == MONSTERVIEW) || (view == ARMYVIEW))
  3173.         glLineWidth(width * 0.011);
  3174.     else
  3175.         glLineWidth(width * 0.0057);
  3176.  
  3177.     glBegin(GL_LINES);
  3178.  
  3179.         glVertex3fv(beamLoc1);
  3180.         glVertex3fv(beamLoc2);
  3181.     glEnd();
  3182.         
  3183.     glDisable(GL_BLEND);
  3184.  
  3185.     glLineWidth(lineWidthNow);
  3186.     } 
  3187.  
  3188. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3189. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3190. /* draw all tanks on the battlefield                             */
  3191. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3192.  
  3193. void drawTanks(struct tank * allTanks,  int counter, struct monsterInfo G,
  3194.                 struct targetInfo * targs, int detail, int view, int wid)
  3195.  
  3196.     {
  3197.     struct tank cTank;
  3198.     struct tank * temptank;
  3199.     float angle2;
  3200.     int monsterIsDead;
  3201.     float height, bottom;
  3202.     float xloc,  zloc;
  3203.     float radToNearestTarget, rad;
  3204.     struct targetInfo * nearestTarget;
  3205.     struct monsterInfo * nearestMonster;
  3206.     struct targetInfo * temptarget;
  3207.     
  3208.  
  3209.     for(temptank = allTanks->next;temptank != NULL;temptank = temptank->next)
  3210.         {
  3211.         cTank = *temptank;
  3212.         
  3213.         if (((fabs(cTank.x) <= PLANESIZE) && (fabs(cTank.z) <= PLANESIZE)) || (view == MAPVIEW))
  3214.             {
  3215.             
  3216.             
  3217.         /* need to find the nearest target */
  3218.         
  3219.         radToNearestTarget = 10000;
  3220.         nearestTarget = NULL;
  3221.         for(temptarget = targs->next;temptarget != NULL;temptarget = temptarget->next)
  3222.             {
  3223.             rad = sqrt((cTank.x-temptarget->x) * (cTank.x-temptarget->x) + (cTank.z-temptarget->z) * (cTank.z-temptarget->z));
  3224.             if (rad < radToNearestTarget)
  3225.                 {
  3226.                 radToNearestTarget = rad;
  3227.                 nearestTarget = temptarget;
  3228.                 nearestMonster = &(temptarget->monster);
  3229.                 }
  3230.             }
  3231.  
  3232.         /* need to compute radius to player's monster */
  3233.  
  3234.         rad = sqrt(cTank.x * cTank.x + cTank.z * cTank.z);
  3235.  
  3236.         if (rad < radToNearestTarget)
  3237.             {
  3238.             radToNearestTarget = rad;
  3239.             nearestMonster = NULL;
  3240.             nearestTarget = NULL;
  3241.             }
  3242.  
  3243.         if (nearestMonster == NULL)
  3244.             {
  3245.             monsterIsDead = G.monsterIsDead;
  3246.             height = G.height;
  3247.             bottom = G.bottom;
  3248.             xloc = 0;
  3249.             zloc = 0;
  3250.             }
  3251.         else
  3252.             {
  3253.             monsterIsDead = nearestMonster->monsterIsDead;
  3254.             height = nearestMonster->height;
  3255.             bottom = nearestMonster->bottom;
  3256.             xloc = nearestTarget->x;
  3257.             zloc = nearestTarget->z;
  3258.             }
  3259.  
  3260.  
  3261.             /**********************************/
  3262.             /* aim vehicle                    */
  3263.             /**********************************/
  3264.  
  3265.             angle2 = cTank.theta * RAD_TO_SMALL_DEG;
  3266.             
  3267.             /**********************************/
  3268.             /* draw vehicle                   */
  3269.             /**********************************/
  3270.                     
  3271.             glPushMatrix();
  3272.  
  3273.             switch (cTank.type)
  3274.                 {
  3275.                 case TANK:      glTranslatef(cTank.x, cTank.y, cTank.z);
  3276.                                 glRotatef(angle2, 0, 1, 0);
  3277.                                 glCallList(plaintank);
  3278.                                 break;
  3279.  
  3280.                 case LAUNCHER:  glTranslatef(cTank.x, cTank.y, cTank.z);
  3281.                                 glRotatef(angle2, 0, 1, 0);
  3282.                                 glCallList(launchertank);
  3283.                                 break;
  3284.                         
  3285.                 case MASERTANK: glTranslatef(cTank.x, cTank.y, cTank.z);
  3286.                                 glRotatef(angle2, 0, 1, 0);
  3287.                                 glScalef(0.15,  0.15,  0.15);
  3288.                                 glCallList(masertank);
  3289.                                 break;
  3290.  
  3291.                 case HELO:      glTranslatef(cTank.x, cTank.y, cTank.z);
  3292.                                 glRotatef(angle2+180, 0, 1, 0);
  3293.                                 drawHelo((counter*9) % 360,  0);
  3294.                                 break;
  3295.  
  3296.                 case AIRPLANE:  glTranslatef(cTank.x, cTank.y, cTank.z);
  3297.                                 glRotatef(angle2+180, 0, 1, 0);
  3298.                                 glScalef(3,  3,  3);
  3299.                                 drawAirplane((counter*2) % 360);
  3300.                                 break;
  3301.  
  3302.                 case FIGHTER:   glTranslatef(cTank.x, cTank.y, cTank.z);
  3303.                                 glRotatef(angle2+180, 0, 1, 0);
  3304.                                 glScalef(2,  2,  2);
  3305.                                 drawFighter();
  3306.                                 break;
  3307.  
  3308.                 case CHH:       glTranslatef(cTank.x, cTank.y, cTank.z);
  3309.                                 glRotatef(angle2, 0, 1, 0);
  3310.                                 makeCHH(cTank.damage);
  3311.                                 break;
  3312.                                 
  3313.                 case MECHAG:    glTranslatef(cTank.x, 0, cTank.z);
  3314.                                 glRotatef(angle2, 0, 1, 0);
  3315.                                 drawMechaMonster(cTank.damage, counter, detail);
  3316.                                 break;
  3317.  
  3318.                 case HERO:      glTranslatef(cTank.x, 0, cTank.z);
  3319.                                 glRotatef(angle2, 0, 1, 0);
  3320.                                 if (cTank.subtype == 0)
  3321.                                     drawHeroDude(cTank.damage, cTank.walking, cTank.maserCount, 0, detail);
  3322.                                 else
  3323.                                     drawHeroDude2(cTank.damage, cTank.walking, cTank.maserCount, 0, detail);
  3324.                                 break;
  3325.                                 
  3326.                 default:        showError("Bogus Vehicle in Tank List! (drawTanks)");
  3327.                                 break;
  3328.                 }
  3329.             
  3330.             glPopMatrix();      
  3331.  
  3332.             if (detail > 0)     
  3333.                 {
  3334.  
  3335.                 /**********************************/
  3336.                 /* draw shadow                    */
  3337.                 /**********************************/
  3338.  
  3339.                 glPushMatrix();
  3340.                     glTranslatef(cTank.x, 0, cTank.z);
  3341.                     glRotatef(angle2, 0, 1, 0);
  3342.  
  3343.                     switch (cTank.type){
  3344.                     case TANK:
  3345.                     case LAUNCHER:
  3346.                     case MASERTANK:     glCallList(tankShadow);
  3347.                                         break;
  3348.                     
  3349.                     case HELO:          glColor4fv(colorblack);
  3350.                                         drawShadow (0, 0, 0.14, 0.18);
  3351.                                         drawShadow (0, -0.22, 0.04, 0.1);
  3352.                                         break;
  3353.                     
  3354.                     case MECHAG:        break;
  3355.                     
  3356.                     case CHH:           glColor4fv(colorblack);
  3357.                                         drawShadow (0, 0, 0.14, 0.22);
  3358.                                         break;
  3359.                     
  3360.                     case HERO:          glColor4fv(colorblack);
  3361.                                         drawShadow (0, 0, 0.12, 0.08);
  3362.                                         break;
  3363.                     
  3364.                     case AIRPLANE:      glCallList(planeShadow);
  3365.                                         break;
  3366.  
  3367.                     case FIGHTER:       glCallList(fighterShadow);      
  3368.                                         break;
  3369.  
  3370.                     default:            showError("Bogus Vehicle in Tank List! (drawTanks)");
  3371.                                         break;
  3372.                     }
  3373.                 glPopMatrix();
  3374.                 }
  3375.   
  3376.             if ((cTank.maserCount > 0) && (cTank.rad <= cTank.range) && (cTank.rad >= 0.5) && (!monsterIsDead))
  3377.                 {
  3378.                 /**********************************/
  3379.                 /* mechaGoogelon firing maser     */
  3380.                 /**********************************/
  3381.  
  3382.                 if (cTank.type == MECHAG)
  3383.                     drawMaser(cTank.x, cTank.y + 0.8, cTank.z, cTank.type, xloc, zloc, height,
  3384.                             bottom, cTank.rand1, cTank.rand2, cTank.rand3, wid, view, detail);
  3385.   
  3386.                 /**********************************/
  3387.                 /* 009CHH firing maser            */
  3388.                 /**********************************/
  3389.         
  3390.                 if (cTank.type == CHH)
  3391.                     drawMaser(cTank.x, cTank.y, cTank.z, cTank.type, xloc, zloc, height,
  3392.                             bottom, cTank.rand1, cTank.rand2, cTank.rand3, wid, view, detail);
  3393.                 
  3394.                 /**********************************/
  3395.                 /* tank firing maser              */
  3396.                 /**********************************/
  3397.  
  3398.                 if (cTank.type == MASERTANK)
  3399.                     drawMaser(cTank.x, cTank.y + 0.375, cTank.z, cTank.type, xloc, zloc, height,
  3400.                             bottom, cTank.rand1, cTank.rand2, cTank.rand3, wid, view, detail);
  3401.   
  3402.                 /**********************************/
  3403.                 /* hero firing its weapon         */
  3404.                 /**********************************/
  3405.  
  3406.                 if ((cTank.type == HERO) && (cTank.subtype == 1) && (cTank.maserCount > 10) && (cTank.maserCount < 30))
  3407.                     if (nearestTarget)
  3408.                         drawHeroWeapon(nearestTarget->x, nearestTarget->z, cTank.x, cTank.y + 0.275, cTank.z, colormaserblue, height, bottom);
  3409.                     else
  3410.                         drawHeroWeapon(0, 0, cTank.x, cTank.y + 0.275, cTank.z, colormaserblue, height, bottom);
  3411.  
  3412.                 } 
  3413.             }  
  3414.         }  
  3415.     }
  3416.  
  3417.  
  3418. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3419. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3420. /* draw hero energy beam                                         */
  3421. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3422.  
  3423. void drawHeroWeapon(float targetx, float targetz, float x, float y,
  3424.                     float z, float * color, float height, float bottom)
  3425.     {
  3426.     float loc1[3],  loc2[3];
  3427.     float rad,  angle,  r;
  3428.     float midPoint;
  3429.     GLboolean backNow;
  3430.     
  3431.     GLint shadeNow;
  3432.     
  3433.     glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
  3434.     backNow = glIsEnabled(GL_CULL_FACE);
  3435.     
  3436.     rad = sqrt(x * x + z * z);
  3437.     
  3438.     if (rad == 0)
  3439.         rad = NEARZERO;
  3440.         
  3441.     r = 0.16 / rad;
  3442.     
  3443.     if (z == 0)
  3444.         z = NEARZERO;
  3445.  
  3446.     angle = atan(x / z);
  3447.  
  3448.     if (z > 0)
  3449.         angle += PI;
  3450.    
  3451.     angle += PI;
  3452.      
  3453.     midPoint = 0.5 * (height - bottom) + bottom;
  3454.     
  3455.     glShadeModel(GL_SMOOTH);
  3456.     glDisable(GL_CULL_FACE);
  3457.     
  3458.     glBegin(GL_QUADS);
  3459.         glColor3fv(color);
  3460.         loc1[0] = (rad - 0.22) * sin(angle + r);
  3461.         loc1[1] = y;
  3462.         loc1[2] = (rad - 0.22) * cos(angle + r);
  3463.         glVertex3fv(loc1);
  3464.             
  3465.         loc1[0] = (rad - 0.22) * sin(angle - r);
  3466.         loc1[2] = (rad - 0.22) * cos(angle - r);
  3467.         glVertex3fv(loc1);
  3468.             
  3469.         glColor3fv(colorwhite); 
  3470.         loc2[0] = targetx - 0.04;
  3471.         loc2[2] = targetz - 0.04;
  3472.         loc2[1] = midPoint;
  3473.         glVertex3fv(loc2);
  3474.             
  3475.         loc2[0] = targetx + 0.04;
  3476.         loc2[2] = targetz + 0.04;
  3477.         glVertex3fv(loc2);
  3478.     glEnd();
  3479.  
  3480.     /* make beam viewable from side */
  3481.  
  3482.     glBegin(GL_QUADS);
  3483.         glColor3fv(color);
  3484.         loc1[0] = (rad - 0.22) * sin(angle);
  3485.         loc1[1] = y + 0.03;
  3486.         loc1[2] = (rad - 0.22) * cos(angle);
  3487.         glVertex3fv(loc1);
  3488.             
  3489.         loc1[1] = y - 0.03;
  3490.         glVertex3fv(loc1);
  3491.             
  3492.         glColor3fv(colorwhite); 
  3493.         loc2[0] = targetx;
  3494.         loc2[2] = targetz;
  3495.         loc2[1] = midPoint - 0.02;
  3496.         glVertex3fv(loc2);
  3497.             
  3498.         loc2[1] = midPoint + 0.02;
  3499.         glVertex3fv(loc2);
  3500.     glEnd();
  3501.         
  3502.     if (backNow)
  3503.         glEnable(GL_CULL_FACE);
  3504.     else
  3505.         glDisable(GL_CULL_FACE);
  3506.         
  3507.     glShadeModel(shadeNow);
  3508.     }
  3509.  
  3510. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3511.  
  3512. void makeBooms()
  3513. {
  3514.     int counter;
  3515.     GLuint O;
  3516.  
  3517.     float spheredat[4];
  3518.         spheredat[0] = 0;
  3519.         spheredat[1] = 0;
  3520.         spheredat[2] = 0;
  3521.     
  3522.     for(counter=1;counter<=10;counter++)
  3523.         {
  3524.         O = glGenLists(1);
  3525.         glNewList(O, GL_COMPILE);
  3526.            
  3527.         spheredat[3] = 0.03 * counter;
  3528.  
  3529.         andysphdraw(spheredat, 3);
  3530.  
  3531.         glEndList();
  3532.  
  3533.         switch(counter)
  3534.             {
  3535.             case 1: boom1Obj = O;
  3536.                     break;
  3537.             case 2: boom2Obj = O;
  3538.                     break;
  3539.             case 3: boom3Obj = O;
  3540.                     break;
  3541.             case 4: boom4Obj = O;
  3542.                     break;
  3543.             case 5: boom5Obj = O;
  3544.                     break;
  3545.             case 6: boom6Obj = O;
  3546.                     break;
  3547.             case 7: boom7Obj = O;
  3548.                     break;
  3549.             case 8: boom8Obj = O;
  3550.                     break;
  3551.             case 9: boom9Obj = O;
  3552.                     break;
  3553.             case 10: boom10Obj = O;
  3554.                     break;
  3555.             }
  3556.  
  3557.         /* Build smaller booms for detail level 0 */
  3558.  
  3559.         O = glGenLists(1);
  3560.         glNewList(O, GL_COMPILE);
  3561.            
  3562.         spheredat[3] = 0.02 * counter;
  3563.  
  3564.         andysphdraw(spheredat, 1);
  3565.  
  3566.         glEndList();
  3567.  
  3568.         switch(counter)
  3569.             {
  3570.             case 1: boom1ObjD0 = O;
  3571.                     break;
  3572.             case 2: boom2ObjD0 = O;
  3573.                     break;
  3574.             case 3: boom3ObjD0 = O;
  3575.                     break;
  3576.             case 4: boom4ObjD0 = O;
  3577.                     break;
  3578.             case 5: boom5ObjD0 = O;
  3579.                     break;
  3580.             case 6: boom6ObjD0 = O;
  3581.                     break;
  3582.             case 7: boom7ObjD0 = O;
  3583.                     break;
  3584.             case 8: boom8ObjD0 = O;
  3585.                     break;
  3586.             case 9: boom9ObjD0 = O;
  3587.                     break;
  3588.             case 10: boom10ObjD0 = O;
  3589.                     break;
  3590.             }
  3591.         }
  3592. }
  3593.  
  3594.  
  3595. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3596. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3597. /* draw explosions                                               */
  3598. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3599.  
  3600. void drawBooms(struct boom * boomers, int detail)
  3601.     {
  3602.     struct boom  * tempboom;
  3603.     struct boom b;
  3604.  
  3605.     if (detail >= 2)
  3606.         glEnable(GL_BLEND);
  3607.  
  3608.     glColor3fv(coloryellow);
  3609.  
  3610.     for(tempboom = boomers->next;tempboom != NULL;tempboom = tempboom->next)
  3611.         {
  3612.         b = *tempboom;
  3613.                 
  3614.         if (detail >= 2)
  3615.             {
  3616.             coloryellow[3] = (11 - b.count) * 0.1;
  3617.             glColor4fv(coloryellow);
  3618.             }
  3619.         
  3620.         glPushMatrix();
  3621.             glTranslatef(b.x, b.y, b.z);
  3622.  
  3623.             if (detail == 0) {
  3624.                 /* Draw smaller 'flickering' explosions (Johan) */
  3625.  
  3626.                 switch(b.count) {
  3627.                 case 1: glCallList(boom1ObjD0);
  3628.                         break;
  3629.                 case 3: glCallList(boom3ObjD0);
  3630.                         break;
  3631.                 case 5: glCallList(boom5ObjD0);
  3632.                         break;
  3633.                 case 7: glCallList(boom7ObjD0);
  3634.                         break;
  3635.                 case 9: glCallList(boom9ObjD0);
  3636.                         break;
  3637.                 }
  3638.  
  3639.             } else {
  3640.  
  3641.                 switch(b.count) {
  3642.                 case 1: glCallList(boom1Obj);
  3643.                         break;
  3644.                 case 2: glCallList(boom2Obj);
  3645.                         break;
  3646.                 case 3: glCallList(boom3Obj);
  3647.                         break;
  3648.                 case 4: glCallList(boom4Obj);
  3649.                         break;
  3650.                 case 5: glCallList(boom5Obj);
  3651.                         break;
  3652.                 case 6: glCallList(boom6Obj);
  3653.                         break;
  3654.                 case 7: glCallList(boom7Obj);
  3655.                         break;
  3656.                 case 8: glCallList(boom8Obj);
  3657.                         break;
  3658.                 case 9: glCallList(boom9Obj);
  3659.                         break;
  3660.                 case 10: glCallList(boom10Obj);
  3661.                         break;
  3662.                 }
  3663.             }
  3664.         glPopMatrix();
  3665.         }
  3666.         
  3667.     if (detail >= 2)
  3668.         glDisable(GL_BLEND);
  3669.     }
  3670.  
  3671. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3672. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3673. /* draw googelon/Flutter's energy beam                           */
  3674. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3675.  
  3676. void drawBeam(float x, float z, int horz, int vert, int monsterName,
  3677.         int detail)
  3678.     {
  3679.     float loc1[3],  loc2[3],  loc3[3];
  3680.     float c[4] = {0, 0, 0, 0};
  3681.     float * col;
  3682.     float R;
  3683.     register int i, nlines;
  3684.     GLfloat lineWidthNow;
  3685.  
  3686.     GLint shadeNow;
  3687.  
  3688.     glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
  3689.  
  3690.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  3691.     
  3692.     if (monsterName == FLUTTER)
  3693.         col = colororange;
  3694.     else
  3695.         col = colorblue;
  3696.  
  3697.             
  3698.     /**********************************/
  3699.     /* draw beam                      */
  3700.     /**********************************/
  3701.  
  3702.     /* if line widths are integral Mesa chokes in a large window */
  3703.     glLineWidth(5.01);
  3704.  
  3705.     if (vert < 175)
  3706.         R = 4;
  3707.     else
  3708.         R = 1.2 / (cos((900 - vert) * BIG_DEG_TO_RAD));
  3709.  
  3710.     if (R < 0)
  3711.         R = 0;
  3712.     if (R > 4)
  3713.         R = 4;
  3714.  
  3715.     if (vert < 0)
  3716.         loc3[1] = PLANEY + 1.2 + R * sin(fabs(vert * BIG_DEG_TO_RAD));
  3717.     else
  3718.         loc3[1] = PLANEY + 1.2 - R * sin(fabs(vert * BIG_DEG_TO_RAD));
  3719.  
  3720.     loc1[0] = x;
  3721.     loc1[2] = z;
  3722.     loc1[1] = PLANEY + 1.2;
  3723.  
  3724. /* this doesnt really work ... beam has xz value of 4 no matter what y is (> plane)
  3725.  * so beam will be longer than 4 as it gets higher up in the sky
  3726.  */
  3727.  
  3728.     loc3[0] = x+R * -cos((900 + horz) * BIG_DEG_TO_RAD);
  3729.     loc3[2] = z+R * sin((900 + horz) * BIG_DEG_TO_RAD);
  3730.  
  3731.     if (loc3[1] < PLANEY)
  3732.         loc3[1] = PLANEY;
  3733.  
  3734.     if (monsterName == FLUTTER)
  3735.         c[0] = 0.95;
  3736.     else
  3737.         c[2] = 0.95;
  3738.  
  3739.     switch (detail)
  3740.         {
  3741.         case -1:
  3742.         case 0: nlines = 4;
  3743.                 break;
  3744.                 
  3745.         case 1: nlines = 25;
  3746.                 glShadeModel(GL_SMOOTH);
  3747.                 break;
  3748.                 
  3749.         case 2: nlines = 40;
  3750.                 glShadeModel(GL_SMOOTH);
  3751.                 break;
  3752.         }
  3753.  
  3754.  
  3755.     for (i = 0; i < nlines; i++)
  3756.         {
  3757.         loc2[0] = loc3[0] + randy(0.04);
  3758.         loc2[1] = loc3[1] + randy(0.04);
  3759.         loc2[2] = loc3[2] + randy(0.04);
  3760.  
  3761.         c[1] = 0.5 + randy(0.5);
  3762.         
  3763.         glBegin(GL_LINES);
  3764.             glColor3fv(c);
  3765.             glVertex3fv(loc2);
  3766.             glColor3fv(col);
  3767.             glVertex3fv(loc1);
  3768.         glEnd();
  3769.         }
  3770.         
  3771.     glShadeModel(shadeNow);
  3772.  
  3773.     if (detail > 0)
  3774.         {
  3775.         /**********************************/
  3776.         /* shadow of beam                 */
  3777.         /**********************************/
  3778.  
  3779.         glColor3fv(colorblack);
  3780.         loc1[1] = SHADOWS;
  3781.         loc3[1] = SHADOWS;
  3782.  
  3783.         glBegin(GL_LINES);
  3784.             glVertex3fv(loc1);
  3785.             glVertex3fv(loc3);
  3786.         glEnd();
  3787.         }
  3788.  
  3789.     glLineWidth(lineWidthNow);
  3790.     }
  3791.  
  3792.  
  3793. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3794. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3795. /* draw roads on the battlefield                                 */
  3796. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  3797.  
  3798. void drawRoads(struct road * roads, float xshift, float zshift,
  3799.                                 int itsChristmas, int view, int detail)
  3800.     {
  3801.     register int i;
  3802.     float displaySize;
  3803.     float square[4][3];
  3804.     float v1[3];
  3805.     float v2[3];
  3806.     float v3[3];
  3807.     float v4[3];
  3808.     float xplus, xminus, zplus, zminus;
  3809.     int ropCounter;
  3810.  
  3811.     static float tv1[2] = {0,1};
  3812.     static float tv2[2] = {1,1};
  3813.     static float tv3[2] = {1,0};
  3814.     static float tv4[2] = {0,0};
  3815.  
  3816.     float c, d;
  3817.     float cprime,  dprime;
  3818.  
  3819.     float xlinemin, xlinemax, zlinemin, zlinemax;
  3820.     float xlinemin2, xlinemax2, zlinemin2, zlinemax2; 
  3821.  
  3822.     GLfloat lineWidthNow;
  3823.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  3824.     
  3825.     xplus   = xshift + 0.252;
  3826.     xminus  = xshift - 0.252;
  3827.     zplus   = zshift + 0.252;
  3828.     zminus  = zshift - 0.252;
  3829.     
  3830.     v1[1] = v2[1] = v3[1] = v4[1] = ROADS + 0.001;
  3831.     
  3832.  
  3833.         
  3834.     /***********************************/
  3835.     /* Draw 'motion' dots on the plane */
  3836.     /***********************************/
  3837.  
  3838.     if (view != MAPVIEW)
  3839.         {
  3840.          c = xshift - (int) xshift;
  3841.          d = zshift - (int) zshift;
  3842.     
  3843.         if (itsChristmas)
  3844.             glColor3fv(colorblack);
  3845.         else
  3846.             glColor3fv(coloryellow);
  3847.             
  3848.         if (c > 0)
  3849.             cprime = c-1;
  3850.         else
  3851.             cprime = c;
  3852.         
  3853.         if (d > 0)
  3854.             dprime = d-1;
  3855.         else
  3856.             dprime = d;
  3857.     
  3858.         /* if line widths are integral Mesa chokes in a large window */
  3859.         glLineWidth(1.01);
  3860.         
  3861.         glPushMatrix();
  3862.             glTranslatef(cprime, 0, dprime);
  3863.             if (detail == 0)
  3864.                 glCallList(planeDotsObjD0);
  3865.             else
  3866.                 glCallList(planeDotsObj);
  3867.         glPopMatrix();
  3868.         }
  3869.  
  3870.  
  3871.     if (view == MAPVIEW)
  3872.         displaySize = 50;
  3873.     else
  3874.         displaySize = PLANESIZE+0.25;
  3875.  
  3876.  
  3877.     if (roads == NULL)
  3878.         return;
  3879.  
  3880.     /***********************************/
  3881.     /* find all the roads on the plane */
  3882.     /***********************************/
  3883.  
  3884.     ropCounter = 0;
  3885.     for(i=0;roads[i].type != NULLROAD;i++)
  3886.         {
  3887.         if ((fabs(roads[i].x+xshift) <= displaySize) && (fabs(roads[i].y+zshift) <= displaySize))
  3888.             {
  3889.             roadsOnPlane[ropCounter] = roads[i];
  3890.             ropCounter++;
  3891.             
  3892.             if (ropCounter >= MAXROADSONPLANE)
  3893.                 ropCounter = MAXROADSONPLANE - 1;
  3894.             }
  3895.         }
  3896.  
  3897.         
  3898.     square[0][1] = square[1][1] = square[2][1] = square[3][1] = ROADS;
  3899.  
  3900.  
  3901.     /********************/
  3902.     /* Draw black roads */
  3903.     /********************/
  3904.  
  3905.     if (ropCounter > 0)
  3906.         {
  3907.         glColor3fv(colorblack);
  3908.  
  3909.         if (detail >= 2) 
  3910.             {
  3911.             glColor3fv(colorwhite);
  3912.             glCallList(roadtex);
  3913.             glEnable(GL_TEXTURE_2D);
  3914.             }
  3915.  
  3916.         glBegin(GL_QUADS);
  3917.  
  3918.         for(i=0; i < ropCounter; i++)
  3919.             {
  3920.             if (roadsOnPlane[i].type < 3)
  3921.                 {
  3922.                 square[0][0] = square[3][0] = roadsOnPlane[i].x+xplus;
  3923.                 square[1][0] = square[2][0] = roadsOnPlane[i].x+xminus;
  3924.     
  3925.                 square[0][2] = square[1][2] = roadsOnPlane[i].y+zplus;
  3926.                 square[2][2] = square[3][2] = roadsOnPlane[i].y+zminus;
  3927.  
  3928.                 if (detail <2)
  3929.                     {
  3930.                     glVertex3fv(square[3]);
  3931.                     glVertex3fv(square[2]);
  3932.                     glVertex3fv(square[1]);
  3933.                     glVertex3fv(square[0]);
  3934.                     }
  3935.                 else
  3936.                     {
  3937.                         glTexCoord2fv(tv1);
  3938.                         glVertex3fv(square[3]);
  3939.                         glTexCoord2fv(tv4);
  3940.                         glVertex3fv(square[2]);
  3941.                         glTexCoord2fv(tv3);
  3942.                         glVertex3fv(square[1]);
  3943.                         glTexCoord2fv(tv2);
  3944.                         glVertex3fv(square[0]);
  3945.                     }
  3946.                 }
  3947.             }
  3948.         glEnd();
  3949.  
  3950.         glDisable(GL_TEXTURE_2D);
  3951.  
  3952.         }
  3953.  
  3954.     /*******************/
  3955.     /* Draw grey roads */
  3956.     /*******************/
  3957.  
  3958.     if (ropCounter > 0)
  3959.         {
  3960.         glColor3fv(colorgrey4);
  3961.     
  3962.         glBegin(GL_QUADS);
  3963.    
  3964.         for(i=0; i < ropCounter; i++)
  3965.             {
  3966.             if (roadsOnPlane[i].type >= 3)
  3967.                 {
  3968.                 square[0][0] = square[3][0] = roadsOnPlane[i].x+xplus;
  3969.                 square[1][0] = square[2][0] = roadsOnPlane[i].x+xminus;
  3970.     
  3971.                 square[0][2] = square[1][2] = roadsOnPlane[i].y+zplus;
  3972.                 square[2][2] = square[3][2] = roadsOnPlane[i].y+zminus;
  3973.             
  3974.                 glVertex3fv(square[3]);
  3975.                 glVertex3fv(square[2]);
  3976.                 glVertex3fv(square[1]);
  3977.                 glVertex3fv(square[0]);
  3978.                 }
  3979.             }
  3980.         glEnd();
  3981.         }
  3982.  
  3983.     if (detail != 0) 
  3984.         {
  3985.         /**************************/
  3986.         /* draw they yellow lines */
  3987.         /**************************/
  3988.      
  3989.         xlinemin = xshift-ROADLINELENGTH;
  3990.         xlinemax = xshift+ROADLINELENGTH;
  3991.         zlinemin = zshift-ROADLINETHICKNESS;
  3992.         zlinemax = zshift+ROADLINETHICKNESS;
  3993.     
  3994.         xlinemin2 = xshift-ROADLINETHICKNESS;
  3995.         xlinemax2 = xshift+ROADLINETHICKNESS;
  3996.         zlinemin2 = zshift-ROADLINELENGTH;
  3997.         zlinemax2 = zshift+ROADLINELENGTH; 
  3998.     
  3999.         glColor3fv(coloryellow);
  4000.     
  4001.         glBegin(GL_QUADS);
  4002.         
  4003.         for(i=0; i < ropCounter; i++)
  4004.             {
  4005.             if(roadsOnPlane[i].type == 0)
  4006.                 {
  4007.                 v1[0] = v4[0] = roadsOnPlane[i].x + xlinemin;
  4008.                 v2[0] = v3[0] = roadsOnPlane[i].x + xlinemax;
  4009.                 
  4010.                 v2[2] = v1[2] = roadsOnPlane[i].y + zlinemin;
  4011.                 v3[2] = v4[2] = roadsOnPlane[i].y + zlinemax;
  4012.                 
  4013.                 glVertex3fv(v1);
  4014.                 glVertex3fv(v4);
  4015.                 glVertex3fv(v3);
  4016.                 glVertex3fv(v2);
  4017.                 }
  4018.                                         
  4019.             else if(roadsOnPlane[i].type == 1)
  4020.                 {                       
  4021.                 v1[2] = v4[2] = roadsOnPlane[i].y + zlinemin2;
  4022.                 v2[2] = v3[2] = roadsOnPlane[i].y + zlinemax2;
  4023.                 
  4024.                 v2[0] = v1[0] = roadsOnPlane[i].x + xlinemin2;
  4025.                 v3[0] = v4[0] = roadsOnPlane[i].x + xlinemax2;
  4026.     
  4027.                 glVertex3fv(v1);
  4028.                 glVertex3fv(v2);
  4029.                 glVertex3fv(v3);
  4030.                 glVertex3fv(v4);
  4031.                 
  4032.                 }
  4033.             else if(roadsOnPlane[i].type == 2)
  4034.                 {                       
  4035.                 v1[2] = v4[2] = roadsOnPlane[i].y + zlinemin;
  4036.                 v2[2] = v3[2] = roadsOnPlane[i].y + zlinemax;
  4037.                 
  4038.                 v2[0] = v1[0] = roadsOnPlane[i].x + xlinemin2;
  4039.                 v3[0] = v4[0] = roadsOnPlane[i].x + xlinemax2;
  4040.     
  4041.                 glVertex3fv(v1);
  4042.                 glVertex3fv(v2);
  4043.                 glVertex3fv(v3);
  4044.                 glVertex3fv(v4);
  4045.                 
  4046.                 }
  4047.             }
  4048.             
  4049.         glEnd();
  4050.         }
  4051.  
  4052.     glLineWidth(lineWidthNow);
  4053.     }
  4054.     
  4055. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  4056. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  4057. /* draw projectiles in flight                                    */
  4058. /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  4059.  
  4060. void drawProjectiles(struct projectile * allProjs, int counter, 
  4061.                     struct fireType * fires, int fireCounter,
  4062.                     int itsChristmas, int detail)
  4063.     {
  4064.     struct projectile *temp;
  4065.     float col[4] = {1.0, 0, 0, 0};
  4066.     float v[3], v2[3];
  4067.     float x, y, z;
  4068.     float floatRatio;
  4069.     register int i;
  4070.     register int rotRatio;
  4071.     int beamCounter;
  4072.  
  4073.     static float beamhitx[MAXBEAMS], beamhitz[MAXBEAMS];
  4074.  
  4075.     GLfloat lineWidthNow;
  4076.     glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
  4077.  
  4078.     /***********************************/
  4079.     /* make standard projectile object */
  4080.     /***********************************/
  4081.   
  4082.     rotRatio = (counter*100) % 3600;
  4083.     
  4084.     floatRatio = rotRatio * 0.1;
  4085.  
  4086.     glDeleteLists( shellObj, 1);
  4087.     glNewList(shellObj, GL_COMPILE);
  4088.  
  4089.         if (detail <= 0)
  4090.             makerrotcubexyflat(0.035, 0.035, 0.035, rotRatio, colorwhite);      
  4091.         else
  4092.             makerrotcubexy(0.05,  0.05,  0.05, rotRatio, colorwhite);   
  4093.  
  4094.         if (itsChristmas)
  4095.             {
  4096.             makerrotcubexy(0.01, 0.051, 0.051, rotRatio, colorred);
  4097.             makerrotcubexy(0.051, 0.051, 0.01, rotRatio, colorred);
  4098.             }
  4099.     glEndList();
  4100.  
  4101.     beamCounter = 0;
  4102.     for (temp = allProjs->next;temp != NULL;temp = temp->next)
  4103.         if ((fabs(temp->x) <= PLANESIZE) && (fabs(temp->z) <= PLANESIZE))
  4104.             {
  4105.             x = temp->x;
  4106.             y = temp->y;
  4107.             z = temp->z;
  4108.     
  4109.             /**********************************/
  4110.             /* draw bomb                      */
  4111.             /**********************************/
  4112.                 
  4113.             switch(temp->type){
  4114.                 case PROJTANK:
  4115.                 case PROJROCKET:glPushMatrix();         /* white cube shells */
  4116.                                     glTranslatef(x,  y,  z);
  4117.                                     glCallList(shellObj);                       
  4118.                                 glPopMatrix();
  4119.                                 if (detail > 0)
  4120.                                     {
  4121.                                     glColor4fv(colorblack);
  4122.                                     drawShadow (x, z, 0.05, 0.05);
  4123.                                     }
  4124.                                 break;
  4125.                                 
  4126.                 case PROJTECHS: glPushMatrix();         /* techs shell */
  4127.                                     glTranslatef(x,  y,  z);
  4128.                                     glRotatef(floatRatio, 1, 0, 0);
  4129.                                     glRotatef(floatRatio, 0, 1, 0);
  4130.                                     glCallList(shell2Obj);
  4131.                                 glPopMatrix();
  4132.                                 if (detail > 0)
  4133.                                     {
  4134.                                     glColor4fv(colorblack);
  4135.                                     drawShadow (x, z, 0.05, 0.05);
  4136.                                     }
  4137.                                 break;
  4138.                                 
  4139.                 case PROJFIRE:  break;                  /* flames */
  4140.                                                                 
  4141.                 case PROJSCAR:  beamhitx[beamCounter] = x;      /* monster beam scar */
  4142.                                 beamhitz[beamCounter] = z;
  4143.                                 beamCounter += 1;
  4144.                                 if (beamCounter >= MAXBEAMS)
  4145.                                     beamCounter -= 1;
  4146.                                 break;
  4147.                                     
  4148.                 case PROJWATER: glPushMatrix();         /* water */
  4149.                                     glTranslatef(x,  y,  z);
  4150.                                     glCallList(watershellObj);
  4151.                                 glPopMatrix();
  4152.                                 break;
  4153.  
  4154.                 case PROJHERO:  glPushMatrix();
  4155.                                     glTranslatef(x,  y,  z);
  4156.                                     glRotatef(floatRatio, 1, 0, 0);
  4157.                                     glRotatef(floatRatio, 0, 1, 0);
  4158.                                     glCallList(heroshellObj);
  4159.                                 glPopMatrix();
  4160.                                 if (detail > 0)
  4161.                                     {
  4162.                                     glColor4fv(colorblack);
  4163.                                     drawShadow (x, z, 0.05, 0.05);
  4164.                                     }
  4165.                                 break;
  4166.     
  4167.                 default:        showError("Bogus Projectile in Projectile List! (drawProjectiles)");
  4168.                                 break;
  4169.                 }
  4170.             }
  4171.  
  4172.  
  4173.     /**********************************/
  4174.     /* draw fires                     */
  4175.     /**********************************/
  4176.             
  4177.     for (i=0;i<fireCounter;i++)
  4178.         {
  4179.         col[1] = fires[i].col;
  4180.         if ((fabs(fires[i].x) <= PLANESIZE) && (fabs(fires[i].z) <= PLANESIZE))
  4181.             makeitPyr(12, col, fires[i].x, PLANEY+fires[i].height, fires[i].z,
  4182.                 fires[i].xwid, fires[i].height, fires[i].zwid);
  4183.         }
  4184.  
  4185.     /**********************************/
  4186.     /* draw scar from monster beam    */
  4187.     /**********************************/
  4188.     
  4189.     glColor3fv(colorblack);
  4190.  
  4191.     /* if line widths are integral Mesa chokes in a large window */
  4192.     glLineWidth(2.01);
  4193.  
  4194.     v[1] = v2[1] = SHADOWS;
  4195.     
  4196.     v2[0] = beamhitx[0];
  4197.     v2[2] = beamhitz[0];
  4198.     
  4199.     for(i=1; i<beamCounter; i++)
  4200.         {
  4201.         v[0] = beamhitx[i];
  4202.         v[2] = beamhitz[i];
  4203.         
  4204.         if ((fabs(v[0] - v2[0]) < 0.3) && (fabs(v[2] - v2[2]) < 0.3))
  4205.             {
  4206.             glBegin(GL_LINES);  
  4207.                 glVertex3fv(v);
  4208.                 glVertex3fv(v2);        
  4209.             glEnd();
  4210.             }
  4211.             
  4212.         v2[0] = v[0];
  4213.         v2[2] = v[2];   
  4214.         }
  4215.  
  4216.     glLineWidth(lineWidthNow);
  4217.     }
  4218.  
  4219.  
  4220. /*
  4221. #define J_SPACE 32
  4222. #define J_DASH 34
  4223.  
  4224. #define J_1 50
  4225. #define J_2 51
  4226. #define J_3 52
  4227. #define J_4 53
  4228. #define J_5 54
  4229. #define J_6 55
  4230. #define J_7 56
  4231. #define J_8 57
  4232. #define J_9 58
  4233.  
  4234.  
  4235. #define J_H_A 65
  4236.  
  4237. #define J_K_A 145
  4238. #define J_K_I 146
  4239. #define J_K_U 147
  4240. #define J_K_E 148
  4241. #define J_K_O 149
  4242.  
  4243. #define J_K_KA 150
  4244. #define J_K_KI 151
  4245. #define J_K_KU 152
  4246. #define J_K_KE 153
  4247. #define J_K_KO 154
  4248.  
  4249. #define J_K_SA 155
  4250. #define J_K_SI 156
  4251. #define J_K_SU 157
  4252. #define J_K_SE 158
  4253. #define J_K_SO 159
  4254.  
  4255. #define J_K_TA 160
  4256. #define J_K_TI 161
  4257. #define J_K_TU 162
  4258. #define J_K_TE 163
  4259. #define J_K_TO 164
  4260.  
  4261. #define J_K_NA 165
  4262. #define J_K_NI 166
  4263. #define J_K_NU 167
  4264. #define J_K_NE 168
  4265. #define J_K_NO 169
  4266.  
  4267. #define J_K_HA 170
  4268. #define J_K_HI 171
  4269. #define J_K_HU 172
  4270. #define J_K_HE 173
  4271. #define J_K_HO 174
  4272.  
  4273. #define J_K_MA 175
  4274. #define J_K_MI 176
  4275. #define J_K_MU 177
  4276. #define J_K_ME 178
  4277. #define J_K_MO 179
  4278.  
  4279. #define J_K_YA 180
  4280. #define J_K_YU 182
  4281. #define J_K_YO 184
  4282.  
  4283. #define J_K_RA 185
  4284. #define J_K_RI 186
  4285. #define J_K_RU 187
  4286. #define J_K_RE 188
  4287. #define J_K_RO 189
  4288.  
  4289. #define J_K_GA 200
  4290. #define J_K_GI 201
  4291. #define J_K_GU 202
  4292. #define J_K_GE 203
  4293. #define J_K_GO 204
  4294.  
  4295. #define J_K_ZA 205
  4296. #define J_K_ZI 206
  4297. #define J_K_ZU 207
  4298. #define J_K_ZE 208
  4299. #define J_K_ZO 209
  4300.  
  4301. #define J_K_DA 210
  4302. #define J_K_DE 213
  4303. #define J_K_DO 214
  4304.  
  4305. #define J_K_BA 215
  4306. #define J_K_BI 216
  4307. #define J_K_BU 217
  4308. #define J_K_BE 218
  4309. #define J_K_BO 219
  4310.  
  4311. #define J_K_PA 220
  4312. #define J_K_PI 221
  4313. #define J_K_PU 222
  4314. #define J_K_PE 223
  4315. #define J_K_PO 224
  4316.  
  4317.  
  4318.     char energyJapanese[]       = {J_K_E, J_K_NE, J_K_RU, J_K_GI, 0};
  4319.     char googelonJapanese[]     = {J_K_GU, J_K_GE, J_K_RO, J_SPACE, J_6, 0};
  4320.     char techsJapanese[]        = {J_K_TE, J_K_TU, J_K_KU, J_K_SU, J_SPACE, J_7, 0};
  4321.     char flutterJapanese[]      = {J_K_HU, J_K_RA, J_K_TU, J_K_TA, J_SPACE, J_9, 0};
  4322.     char vapourJapanese[]       = {J_K_ZA, J_DASH, J_K_BE, J_DASH, J_K_PA, J_DASH, J_SPACE, J_8, 0};
  4323. */
  4324.  
  4325.